@fusion.dev/helix-core 0.215.3 → 0.217.0

package/dist/utils/sonify/sonify.d.ts

@@ -0,0 +1,62 @@
+/** One series to play: its name and its readings, a missing one as `null`. */
+export interface SoundSeries {
+    name: string;
+    values: ReadonlyArray<number | null>;
+}
+/** One sound of a plan. */
+export interface Sound {
+    /** Hertz, for a tone. */
+    frequency: number;
+    kind: 'tick' | 'tone';
+    /** Seconds. */
+    length: number;
+    /** From -1, the left ear, to 1, the right. */
+    pan: number;
+    /** Which series, which picks its timbre. */
+    series: number;
+    /** Seconds from the start. */
+    time: number;
+}
+/** The lowest and highest pitch, two octaves apart, in hertz. */
+export declare const LOW = 220;
+export declare const HIGH = 880;
+/** The timbres, one a series, in turn. */
+export declare const TIMBRES: readonly OscillatorType[];
+/**
+ * The pitch a value is played at: two octaves across the value axis, on a log
+ * scale, so equal steps in value sound like equal steps in pitch.
+ */
+export declare const pitchOf: (value: number, min: number, max: number) => number;
+/** Where a reading at this place of `count` sits between the ears. */
+export declare const panOf: (place: number, count: number) => number;
+/** What a sweep plays, each series after the one before, over `duration` seconds apiece. */
+export declare const sweepPlan: (series: readonly SoundSeries[], options: {
+    duration: number;
+    max: number;
+    min: number;
+}) => Sound[];
+/**
+ * Plays plans on Web Audio, one at a time.
+ *
+ * **The audio context is made on the first play**, which a page reaches only
+ * from a reader's press: a browser refuses to start sound that no gesture
+ * asked for.
+ */
+export declare class ChartSound {
+    private context;
+    private playing;
+    private ending;
+    private finish;
+    /** Whether this browser can play sound at all. */
+    static get available(): boolean;
+    /** Plays a plan, stopping whatever was playing, and resolves when it ends or is stopped. */
+    play(plan: readonly Sound[], volume?: number): Promise<void>;
+    /** Stops whatever is playing. */
+    stop(): void;
+    /**
+     * Stops, and lets the audio context go, as a chart leaves the page: a
+     * browser allows a page a few contexts, and each holds the audio device.
+     * The next play makes another.
+     */
+    close(): void;
+}

package/dist/utils/sonify/sonify.js

@@ -0,0 +1,130 @@
+export const LOW = 220;
+export const HIGH = 880;
+export const TIMBRES = ['sine', 'triangle', 'square', 'sawtooth'];
+export const pitchOf = (value, min, max) => {
+    const share = max === min ? 0.5 : Math.min(1, Math.max(0, (value - min) / (max - min)));
+    return LOW * (HIGH / LOW) ** share;
+};
+export const panOf = (place, count) => count <= 1 ? 0 : -1 + (2 * place) / (count - 1);
+export const sweepPlan = (series, options) => {
+    const sounds = [];
+    const gap = 0.4;
+    series.forEach((one, depth) => {
+        const start = depth * (options.duration + gap);
+        const count = one.values.length;
+        const step = count > 1 ? options.duration / (count - 1) : 0;
+        const length = Math.min(0.2, Math.max(0.05, step * 0.8));
+        const ticks = count <= 12 ? count : 11;
+        for (let tick = 0; tick < ticks; tick += 1) {
+            const place = ticks > 1 ? tick / (ticks - 1) : 0;
+            sounds.push({
+                frequency: 0,
+                kind: 'tick',
+                length: 0.02,
+                pan: -1 + 2 * place,
+                series: depth,
+                time: start + place * options.duration,
+            });
+        }
+        one.values.forEach((value, place) => {
+            if (value === null || !Number.isFinite(value)) {
+                return;
+            }
+            sounds.push({
+                frequency: pitchOf(value, options.min, options.max),
+                kind: 'tone',
+                length,
+                pan: panOf(place, count),
+                series: depth,
+                time: start + place * step,
+            });
+        });
+    });
+    return sounds.sort((a, b) => a.time - b.time);
+};
+export class ChartSound {
+    constructor() {
+        this.playing = [];
+    }
+    static get available() {
+        return typeof globalThis.AudioContext === 'function';
+    }
+    play(plan, volume = 0.25) {
+        this.stop();
+        if (!ChartSound.available || plan.length === 0) {
+            return Promise.resolve();
+        }
+        this.context ??= new AudioContext();
+        const context = this.context;
+        void context.resume();
+        const begin = context.currentTime + 0.05;
+        let last = 0;
+        for (const sound of plan) {
+            const at = begin + sound.time;
+            last = Math.max(last, sound.time + sound.length);
+            const gain = context.createGain();
+            const pan = context.createStereoPanner();
+            pan.pan.value = sound.pan;
+            gain.connect(pan).connect(context.destination);
+            let source;
+            if (sound.kind === 'tick') {
+                const buffer = context.createBuffer(1, Math.ceil(context.sampleRate * sound.length), context.sampleRate);
+                const samples = buffer.getChannelData(0);
+                for (let index = 0; index < samples.length; index += 1) {
+                    samples[index] = (Math.random() * 2 - 1) * (1 - index / samples.length);
+                }
+                const noise = context.createBufferSource();
+                noise.buffer = buffer;
+                gain.gain.value = volume * 0.25;
+                source = noise;
+            }
+            else {
+                const oscillator = context.createOscillator();
+                oscillator.type = TIMBRES[sound.series % TIMBRES.length] ?? 'sine';
+                oscillator.frequency.value = sound.frequency;
+                gain.gain.setValueAtTime(0, at);
+                gain.gain.linearRampToValueAtTime(volume, at + 0.01);
+                gain.gain.linearRampToValueAtTime(0, at + sound.length);
+                if (oscillator.type === 'square' || oscillator.type === 'sawtooth') {
+                    const filter = context.createBiquadFilter();
+                    filter.type = 'lowpass';
+                    filter.frequency.value = 1800;
+                    oscillator.connect(filter).connect(gain);
+                }
+                else {
+                    oscillator.connect(gain);
+                }
+                source = oscillator;
+            }
+            if (sound.kind === 'tick') {
+                source.connect(gain);
+            }
+            source.start(at);
+            source.stop(at + sound.length);
+            this.playing.push(source);
+        }
+        return new Promise((resolve) => {
+            this.finish = resolve;
+            this.ending = setTimeout(() => this.stop(), (last + 0.1) * 1000);
+        });
+    }
+    stop() {
+        clearTimeout(this.ending);
+        const finish = this.finish;
+        this.finish = undefined;
+        for (const source of this.playing) {
+            try {
+                source.stop();
+            }
+            catch {
+            }
+        }
+        this.playing = [];
+        finish?.();
+    }
+    close() {
+        this.stop();
+        void this.context?.close().catch(() => { });
+        this.context = undefined;
+    }
+}

package/dist/utils/speech/speech.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What a field listens through when a reader dictates into it.
+ *
+ * **An engine is an interface, so the browser's recognizer is one engine of
+ * several.** Helix ships `browserSpeech`, on the Web Speech API, and an app
+ * with recognizers of its own, a desktop shell with a local model or a
+ * service with a streaming API, registers one with `registerSpeechEngine` for
+ * every field on the page, or gives one field its own through `speechEngine`.
+ */
+/** What an engine tells a field as it listens. */
+export interface SpeechListener {
+    /** Listening stopped, because it was asked to, because the engine ended, or because of an error. */
+    end(reason: 'ended' | 'error' | 'stopped', message?: string): void;
+    /** A phrase the engine has settled on. The guess before it is replaced by it. */
+    final(text: string): void;
+    /** How loud the microphone is, from 0 to 1, with the spectrum's bands where the engine has them. */
+    level?(level: number, bands?: readonly number[]): void;
+    /** The engine's guess at the phrase being spoken, which the next guess or `final` replaces. */
+    partial(text: string): void;
+}
+/** A listening an engine started, which the field stops. */
+export interface SpeechSession {
+    stop(): void;
+}
+/** A speech recognizer a field can listen through. */
+export interface SpeechEngine {
+    /** Whether the engine can listen on this page now. A field draws no dictation button where it cannot. */
+    available(): boolean;
+    /** Starts listening in a language, a BCP 47 tag such as `en-US`, telling `listener` what it hears. */
+    listen(options: {
+        lang: string;
+        listener: SpeechListener;
+    }): SpeechSession;
+}
+/**
+ * The browser's own recognizer, `SpeechRecognition`, or `webkitSpeechRecognition`
+ * in Safari. Not available in Firefox.
+ *
+ * **Chrome sends the audio to Google's servers to recognize it**, and Safari
+ * to Apple's unless the device recognizes on the device. A page that cannot
+ * send what is said registers an engine of its own.
+ */
+export declare const browserSpeech: SpeechEngine;
+/**
+ * Gives every field on the page an engine to listen through, in place of the
+ * browser's own, or takes it away again with `undefined`. A field's own
+ * `speechEngine` wins over it.
+ */
+export declare const registerSpeechEngine: (engine: SpeechEngine | undefined) => void;
+/** The engine a field listens through where it was given none of its own. */
+export declare const pageSpeechEngine: () => SpeechEngine;

package/dist/utils/speech/speech.js

@@ -0,0 +1,118 @@
+const recognizer = () => {
+    const scope = globalThis;
+    return scope.SpeechRecognition ?? scope.webkitSpeechRecognition;
+};
+const meter = (report) => {
+    let stopped = false;
+    let release = () => { };
+    const devices = globalThis.navigator?.mediaDevices;
+    const Context = globalThis.AudioContext;
+    if (!devices?.getUserMedia || !Context) {
+        return () => { };
+    }
+    void devices
+        .getUserMedia({ audio: true })
+        .then((stream) => {
+        if (stopped) {
+            for (const track of stream.getTracks()) {
+                track.stop();
+            }
+            return;
+        }
+        const context = new Context();
+        const tap = context.createAnalyser();
+        tap.fftSize = 256;
+        context.createMediaStreamSource(stream).connect(tap);
+        const samples = new Uint8Array(tap.fftSize);
+        const spectrum = new Uint8Array(tap.frequencyBinCount);
+        const timer = setInterval(() => {
+            tap.getByteTimeDomainData(samples);
+            tap.getByteFrequencyData(spectrum);
+            let sum = 0;
+            for (const sample of samples) {
+                const centered = (sample - 128) / 128;
+                sum += centered * centered;
+            }
+            const level = Math.min(1, Math.sqrt(sum / samples.length) * 4);
+            const bands = Array.from({ length: 8 }, (_, band) => {
+                const from = Math.floor((band / 8) * spectrum.length);
+                const to = Math.floor(((band + 1) / 8) * spectrum.length);
+                let peak = 0;
+                for (let at = from; at < to; at += 1) {
+                    peak = Math.max(peak, spectrum[at] ?? 0);
+                }
+                return peak / 255;
+            });
+            report(level, bands);
+        }, 50);
+        release = () => {
+            clearInterval(timer);
+            for (const track of stream.getTracks()) {
+                track.stop();
+            }
+            void context.close();
+        };
+    })
+        .catch(() => { });
+    return () => {
+        stopped = true;
+        release();
+    };
+};
+export const browserSpeech = {
+    available: () => recognizer() !== undefined,
+    listen: ({ lang, listener }) => {
+        const Constructor = recognizer();
+        if (!Constructor) {
+            listener.end('error', 'This browser has no speech recognition.');
+            return { stop: () => { } };
+        }
+        const recognition = new Constructor();
+        recognition.continuous = true;
+        recognition.interimResults = true;
+        recognition.lang = lang;
+        let asked = false;
+        let failed;
+        const quiet = meter((level, bands) => listener.level?.(level, bands));
+        recognition.onresult = (event) => {
+            let guess = '';
+            for (let at = event.resultIndex; at < event.results.length; at += 1) {
+                const result = event.results[at];
+                const text = result[0]?.transcript ?? '';
+                if (result.isFinal) {
+                    listener.final(text.trim());
+                }
+                else {
+                    guess += text;
+                }
+            }
+            if (guess !== '') {
+                listener.partial(guess.trim());
+            }
+        };
+        recognition.onerror = (event) => {
+            failed = event.error;
+        };
+        recognition.onend = () => {
+            quiet();
+            listener.end(failed && failed !== 'aborted' ? 'error' : asked ? 'stopped' : 'ended', failed);
+        };
+        recognition.start();
+        return {
+            stop: () => {
+                asked = true;
+                recognition.stop();
+            },
+        };
+    },
+};
+const KEY = Symbol.for('fusion.helix.speech');
+const globals = globalThis;
+if (globals[KEY] === undefined) {
+    globals[KEY] = { engine: undefined };
+}
+const holder = globals[KEY];
+export const registerSpeechEngine = (engine) => {
+    holder.engine = engine;
+};
+export const pageSpeechEngine = () => holder.engine ?? browserSpeech;

package/dist/utils/state/state.d.ts

@@ -0,0 +1,79 @@
+/** What one element holds, as a snapshot keeps it. */
+export interface ElementState {
+    /** The caret or selection in its field, start and end. */
+    caret?: [number, number];
+    checked?: boolean;
+    open?: boolean;
+    /** Where each box it scrolls is scrolled, in the order the boxes are drawn, as `[left, top]`. */
+    scroll?: Array<[number, number]>;
+    value?: string;
+}
+/** A screen, as `captureState` writes it. */
+export interface PageState {
+    /** One entry per Helix element with something to keep, in document order. */
+    entries: Array<{
+        path: string;
+        state: ElementState;
+        tag: string;
+    }>;
+    /** The element focus was on, by its path. */
+    focus?: string;
+    /** The document's own scroll, `[left, top]`. */
+    scroll: [number, number];
+    version: 1;
+    /** The viewport the screen was captured at, `[width, height]`. */
+    viewport: [number, number];
+}
+/** What `restoreState` did. */
+export interface RestoreReport {
+    /** How many entries were put back. */
+    applied: number;
+    /** Paths that found no element, such as one the page no longer draws. */
+    missed: string[];
+    /** Paths whose element refused a request, which the page decided. */
+    refused: string[];
+}
+/** What one Helix element holds that a snapshot keeps, or nothing where it holds none. */
+export declare const snapshotOf: (element: HTMLElement) => ElementState | undefined;
+/**
+ * Puts one element's state back, through the requests a reader's action
+ * makes, and returns whether every request was granted.
+ */
+export declare const restoreOn: (element: HTMLElement, state: ElementState) => Promise<boolean>;
+/**
+ * A path that finds an element again on the same page: its `id` where it has
+ * one, and otherwise its tag and its place among the elements of that tag in
+ * its tree, with `>>` crossing into a shadow root.
+ */
+export declare const pathOf: (element: Element) => string;
+/** The element a path names, or nothing where the page no longer draws it. */
+export declare const elementAt: (path: string, root?: Document) => Element | null;
+/** The screen as it is: every Helix element's state, the focus, the scroll and the viewport. */
+export declare const captureState: (root?: Document) => PageState;
+/**
+ * Puts a screen back: each entry in document order, each element waiting for
+ * its definition and its update so an opened overlay has drawn its rows
+ * before a row inside it is restored, then the focus and the scroll.
+ */
+export declare const restoreState: (snapshot: PageState, root?: Document) => Promise<RestoreReport>;
+/**
+ * Where a page's capture and restore are found without importing anything,
+ * such as by `helix visual`'s driver, which reaches a page only through its
+ * globals: `globalThis[Symbol.for('fusion.dev/helix/state')]`.
+ *
+ * **Empty unless asked for.** A page that exposed it by default would hand
+ * every script on it the text in every field and a way to drive each element.
+ * The page asks by calling `exposeState()`. A tool that drives a page it did
+ * not write, such as `helix visual` or an agent's browser, asks before the
+ * page loads by setting the slot to `true`, and the first copy of Helix to
+ * load fills it.
+ *
+ * **On `globalThis` and not on the element classes**, for the reason
+ * `noteVersion` gives: a static would be listed on every reference page. The
+ * first copy of Helix on a page keeps the slot.
+ */
+export declare const STATE_SLOT: unique symbol;
+/** Puts `captureState` and `restoreState` where a page's tools find them, once. */
+export declare const exposeState: () => void;
+/** Exposes the state tools where a tool set the slot to `true` before the page loaded. */
+export declare const exposeStateIfAsked: () => void;

package/dist/utils/state/state.js

@@ -0,0 +1,165 @@
+import { deepActiveElement } from '../focusable-elements/focusable-elements.js';
+const isHelix = (element) => typeof element.constructor.tier === 'string';
+const parentOf = (element) => element.parentElement ??
+    element.getRootNode().host ??
+    null;
+const excluded = (element) => {
+    for (let at = element; at; at = parentOf(at)) {
+        if (at.getAttribute('snapshot') === 'off') {
+            return true;
+        }
+    }
+    return false;
+};
+const fieldOf = (element) => element.shadowRoot?.querySelector('input:not([type="hidden"]), textarea') ?? null;
+const SECRET_TOKEN = /^(?:cc-.+|current-password|new-password|one-time-code)$/;
+const secret = (element) => {
+    const field = fieldOf(element);
+    const type = element.type ?? field?.type;
+    const autocomplete = element.getAttribute('autocomplete') ?? field?.getAttribute('autocomplete') ?? '';
+    return (type === 'password' ||
+        autocomplete
+            .toLowerCase()
+            .split(/\s+/)
+            .some((token) => SECRET_TOKEN.test(token)));
+};
+export const snapshotOf = (element) => {
+    const stateful = element;
+    const state = {};
+    if (typeof stateful.requestOpen === 'function' && typeof stateful.open === 'boolean') {
+        state.open = stateful.open;
+    }
+    if (typeof stateful.requestChecked === 'function' && typeof stateful.checked === 'boolean') {
+        state.checked = stateful.checked;
+    }
+    if (typeof stateful.requestValue === 'function' &&
+        typeof stateful.value === 'string' &&
+        !secret(element)) {
+        state.value = stateful.value;
+    }
+    const boxes = [...(element.shadowRoot?.querySelectorAll('[data-scroller]') ?? [])];
+    if (boxes.some((box) => box.scrollTop !== 0 || box.scrollLeft !== 0)) {
+        state.scroll = boxes.map((box) => [box.scrollLeft, box.scrollTop]);
+    }
+    const field = fieldOf(element);
+    if (field && deepActiveElement() === field && field.selectionStart !== null && !secret(element)) {
+        state.caret = [field.selectionStart, field.selectionEnd ?? field.selectionStart];
+    }
+    return Object.keys(state).length > 0 ? state : undefined;
+};
+export const restoreOn = async (element, state) => {
+    const stateful = element;
+    let granted = true;
+    if (state.value !== undefined && stateful.value !== state.value) {
+        granted = (stateful.requestValue?.(state.value) ?? false) && granted;
+    }
+    if (state.checked !== undefined && stateful.checked !== state.checked) {
+        granted = (stateful.requestChecked?.(state.checked) ?? false) && granted;
+    }
+    if (state.open !== undefined && stateful.open !== state.open) {
+        granted = (stateful.requestOpen?.(state.open) ?? false) && granted;
+    }
+    await stateful.updateComplete;
+    const boxes = [...(element.shadowRoot?.querySelectorAll('[data-scroller]') ?? [])];
+    state.scroll?.forEach(([left, top], index) => {
+        boxes[index]?.scrollTo({ behavior: 'instant', left, top });
+    });
+    if (state.caret) {
+        const field = fieldOf(element);
+        field?.focus();
+        field?.setSelectionRange(state.caret[0], state.caret[1]);
+    }
+    return granted;
+};
+export const pathOf = (element) => {
+    const steps = [];
+    for (let at = element; at;) {
+        const root = at.getRootNode();
+        const tag = at.localName;
+        const id = at.id;
+        const unique = id !== '' && root.querySelectorAll(`#${CSS.escape(id)}`).length === 1;
+        steps.unshift(unique ? `#${id}` : `${tag}:${[...root.querySelectorAll(tag)].indexOf(at)}`);
+        at = root instanceof ShadowRoot ? root.host : null;
+    }
+    return steps.join(' >> ');
+};
+export const elementAt = (path, root = document) => {
+    let scope = root;
+    let found = null;
+    for (const step of path.split(' >> ')) {
+        if (!scope) {
+            return null;
+        }
+        if (step.startsWith('#')) {
+            found = scope.querySelector(`#${CSS.escape(step.slice(1))}`);
+        }
+        else {
+            const [tag = '', index = '0'] = step.split(':');
+            found = scope.querySelectorAll(tag)[Number(index)] ?? null;
+        }
+        scope = found?.shadowRoot ?? null;
+    }
+    return found;
+};
+const everyElement = (root) => [...root.querySelectorAll('*')].flatMap((element) => [
+    element,
+    ...(element.shadowRoot ? everyElement(element.shadowRoot) : []),
+]);
+export const captureState = (root = document) => {
+    const entries = everyElement(root)
+        .filter(isHelix)
+        .filter((element) => !excluded(element))
+        .flatMap((element) => {
+        const state = snapshotOf(element);
+        return state ? [{ path: pathOf(element), state, tag: element.localName }] : [];
+    });
+    const focus = deepActiveElement();
+    const view = root.defaultView;
+    return {
+        entries,
+        ...(focus && focus !== root.body ? { focus: pathOf(focus) } : {}),
+        scroll: [view?.scrollX ?? 0, view?.scrollY ?? 0],
+        version: 1,
+        viewport: [view?.innerWidth ?? 0, view?.innerHeight ?? 0],
+    };
+};
+export const restoreState = async (snapshot, root = document) => {
+    const report = { applied: 0, missed: [], refused: [] };
+    for (const entry of snapshot.entries) {
+        await customElements.whenDefined(entry.tag);
+        const element = elementAt(entry.path, root);
+        if (!(element instanceof HTMLElement)) {
+            report.missed.push(entry.path);
+            continue;
+        }
+        await element.updateComplete;
+        if (await restoreOn(element, entry.state)) {
+            report.applied += 1;
+        }
+        else {
+            report.refused.push(entry.path);
+        }
+    }
+    if (snapshot.focus) {
+        const target = elementAt(snapshot.focus, root);
+        target?.focus?.();
+    }
+    root.defaultView?.scrollTo({
+        behavior: 'instant',
+        left: snapshot.scroll[0],
+        top: snapshot.scroll[1],
+    });
+    return report;
+};
+export const STATE_SLOT = Symbol.for('fusion.dev/helix/state');
+export const exposeState = () => {
+    const store = globalThis;
+    if (typeof store[STATE_SLOT] !== 'object') {
+        store[STATE_SLOT] = { captureState, restoreState };
+    }
+};
+export const exposeStateIfAsked = () => {
+    if (globalThis[STATE_SLOT] === true) {
+        exposeState();
+    }
+};

package/dist/utils/ticker/ticker.d.ts

@@ -5,12 +5,7 @@
  * on the machine: a spec that subscribes at 1000ms and waits 1400 is measuring
  * how loaded the runner is, and a loaded runner eats 400ms. One did, on a green
  * branch, and blocked a merge that had nothing wrong with it. A bigger margin is
- * the same bug at a lower rate.
- *
- * Bun 1.1.43 is what this workspace pins, and it has `jest.useFakeTimers()`
- * without `jest.advanceTimersByTime`, so there is nothing to advance a faked
- * timer with. Measured rather than assumed: a spec asserting that function
- * exists throws.
+ * the same bug at a lower rate. A spec passes its own `now` and `setTimer`.
  */
 export interface Clock {
     clearTimer: (timer: ReturnType<typeof setTimeout>) => void;

package/dist/version.d.ts

@@ -6,4 +6,4 @@
  * release, so the two never disagree; a spec beside this holds them to it.
  * Nothing else in the running code knows which release it is.
  */
-export declare const VERSION = "0.215.3";
+export declare const VERSION = "0.217.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.215.3';
+export const VERSION = '0.217.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-core",
   "description": "Helix element primitives: base classes, mixins, decorators, utilities.",
-  "version": "0.215.3",
+  "version": "0.217.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -81,12 +81,12 @@
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@fusion.dev/helix-icons": "0.215.3",
+    "@fusion.dev/helix-icons": "0.217.0",
     "tslib": "^2.8.1"
   },
   "devDependencies": {
-    "@fusion.dev/helix-cem": "0.215.3",
-    "@fusion.dev/helix-testing": "0.215.3",
+    "@fusion.dev/helix-cem": "0.217.0",
+    "@fusion.dev/helix-testing": "0.217.0",
     "@lit-labs/ssr": "^4.1.0",
     "lit": "^3.2.1"
   },