@fusion.dev/helix-core 0.223.1 → 0.225.0

package/dist/events/navigate.d.ts

@@ -1,11 +1,9 @@
 import type { NavigateDetail } from './details.js';
 /**
- * Fired when a component moves the view it is showing, rather than its value.
+ * A component moved the view it is showing.
  *
- * A calendar paging to another month is not choosing a date, and the two have
- * to be separable: a consumer driving the view needs to hear that it moved
- * without being told the answer changed. `helix-change` belongs to the value,
- * and giving it both jobs would make either one unusable on its own.
+ * The notification after `helix-before-navigate`, sent once the view has moved,
+ * with where it is now. Not cancelable: the decision was the request's.
  */
 export declare class HelixNavigateEvent extends CustomEvent<NavigateDetail> {
     static readonly eventName = "helix-navigate";

package/dist/events/navigate.js

@@ -3,7 +3,7 @@ export class HelixNavigateEvent extends CustomEvent {
     constructor(detail) {
         super(HelixNavigateEvent.eventName, {
             bubbles: true,
-            cancelable: true,
+            cancelable: false,
             composed: true,
             detail,
         });

package/dist/events/reorder.d.ts

@@ -1,22 +1,21 @@
 import type { ReorderDetail } from './details.js';
 /**
- * Fired when you ask for a row, an item, or a column to move to a new place.
+ * A row, an item, or a column moved to a new place.
  *
- * **For rows and items, you move them.** Helix moves no element it does not
- * own, so a list or a data table sends this after `helix-before-reorder`, and
- * you move your data to the order in `keys`. Calling `preventDefault()` says
- * the move did not happen, and the element tells a screen reader it was
- * canceled.
+ * The notification after `helix-before-reorder`, with every key in the new
+ * order. Not cancelable: the decision was the request's.
  *
- * **For Data Table's columns, the table moves them.** Calling
- * `preventDefault()` leaves the columns where they were, so you can store the
- * order in a URL or a preference and decide it yourself, the way a server-side
- * sort takes `helix-sort`. `value` is the whole order as fields separated by
- * spaces, which is what `order` takes.
+ * **For rows and items, you move them.** Helix moves no element it does not own,
+ * so a list or a data table sends this once the move stands, and you move your
+ * data to the order in `keys`.
+ *
+ * **For Data Table's columns, the table has moved them** by the time this
+ * arrives, and `value` is the whole order as fields separated by spaces, which
+ * is what `order` holds.
  *
  * `kind` says which of the three moved, since a data table sends this for its
- * rows and for its columns. `helix-sort` orders rows by a column, and this
- * moves one row or column by hand.
+ * rows and for its columns. `helix-sort` reports rows ordered by a column, and
+ * this reports one row or column moved by hand.
  */
 export declare class HelixReorderEvent extends CustomEvent<ReorderDetail> {
     static readonly eventName = "helix-reorder";

package/dist/events/reorder.js

@@ -3,7 +3,7 @@ export class HelixReorderEvent extends CustomEvent {
     constructor(detail) {
         super(HelixReorderEvent.eventName, {
             bubbles: true,
-            cancelable: true,
+            cancelable: false,
             composed: true,
             detail,
         });

package/dist/events/select.d.ts

@@ -1,10 +1,10 @@
 import type { SelectDetail } from './details.js';
 /**
- * Fired when the reader selects an item in a set.
+ * A set holds a different selection.
  *
- * Bubbles and is composed, because this is how a set coordinates: a tree, a
- * tab list and a toggle group all learn which of their children was chosen by
- * hearing it arrive.
+ * The notification after a `helix-before-select` that asked to change what is
+ * selected, sent once the selection has moved, with the selection now in
+ * force. Not cancelable: the decision was the request's.
  */
 export declare class HelixSelectEvent extends CustomEvent<SelectDetail> {
     static readonly eventName = "helix-select";

package/dist/events/select.js

@@ -3,7 +3,7 @@ export class HelixSelectEvent extends CustomEvent {
     constructor(detail) {
         super(HelixSelectEvent.eventName, {
             bubbles: true,
-            cancelable: true,
+            cancelable: false,
             composed: true,
             detail,
         });

package/dist/events/sort.d.ts

@@ -1,15 +1,9 @@
 import type { SortDetail } from './details.js';
 /**
- * Fired when the reader asks for a different order.
+ * The rows are in a different order.
  *
- * Cancelable, and refusing it leaves the order alone, which is what makes a
- * server-side sort expressible: the consumer refuses the local reorder, fetches,
- * and hands back a new set. This is the element reporting that a heading was
- * clicked, before it acts on it.
- *
- * Not `helix-change`: nothing about the data changed, only the order it is read
- * in, and a consumer listening for changes to a value should not hear a sort.
- * That is the same distinction `helix-filter` is drawn on.
+ * The notification after `helix-before-sort`, sent once `sort` has moved, with
+ * the order now in force. Not cancelable: the decision was the request's.
  */
 export declare class HelixSortEvent extends CustomEvent<SortDetail> {
     static readonly eventName = "helix-sort";

package/dist/events/sort.js

@@ -3,7 +3,7 @@ export class HelixSortEvent extends CustomEvent {
     constructor(detail) {
         super(HelixSortEvent.eventName, {
             bubbles: true,
-            cancelable: true,
+            cancelable: false,
             composed: true,
             detail,
         });

package/dist/helix-element/helix-element.d.ts

@@ -1,5 +1,22 @@
 import { type CSSResultOrNative, LitElement, type PropertyValues } from 'lit';
 import type { StaticValue } from 'lit/static-html.js';
+/**
+ * @internal The `ElementInternals` an element attached: the role, the name,
+ * the states and the form value it sets without touching the DOM.
+ *
+ * **Off the element, as the platform means them to be.** `attachInternals`
+ * throws on a second call so that only the element holds its internals. Kept
+ * on the element as a property, `protected` in the types and a plain field at
+ * run time, any script could call `element.internals.setFormValue()` or set
+ * its role. The headless and styled tiers subclass this class from other
+ * packages, so no member is private to every class that needs them; a
+ * module-scoped map takes them off the element's surface, and this is how a
+ * subclass reaches its own.
+ *
+ * Available during server rendering. Lit's shim implements `attachInternals`,
+ * so nothing here needs a guard.
+ */
+export declare const internalsOf: (element: HelixElement) => ElementInternals;
 /**
  * @summary Base class every Helix element extends.
  *
@@ -84,19 +101,6 @@ export declare class HelixElement extends LitElement {
      * rather than a null an optional chain swallows.
      */
     protected partNamed<T extends Element = HTMLElement>(name: string): T | null;
-    /**
-     * The element's semantics, set without touching the DOM.
-     *
-     * `ElementInternals` sets the implicit role, which an author's own `role`
-     * attribute still overrides, and it writes no attribute. Setting `role` on the
-     * host directly would: that is an attribute the element gives itself after it
-     * upgrades, which a React consumer's server markup never had, and hydration
-     * reports it as a mismatch.
-     *
-     * Available during server rendering. Lit's shim implements `attachInternals`,
-     * so nothing here needs a guard.
-     */
-    protected readonly internals: ElementInternals;
     /**
      * Records a boolean fact about this element as a custom state.
      *
@@ -288,6 +292,19 @@ export declare class HelixElement extends LitElement {
      * shadow root gets, which is what keeps the other four out of a Button.
      */
     protected static markRules: readonly string[];
+    /**
+     * Each attribute Lit observes, and each camelCase property's name in lower
+     * case.
+     *
+     * React writes an attribute for a prop on an element that is not defined yet,
+     * and on a server, and HTML lowers its name. So `defaultPosition={16}` arrives
+     * as `defaultposition`, which names no property Lit knows, and the value was
+     * dropped with no error. `attributeChangedCallback` reads the lowered name as
+     * the property's own attribute, so either spelling works in either order.
+     */
+    static get observedAttributes(): string[];
+    /** @internal Called by the browser when an observed attribute changes. */
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
     /**
      * Prepends the shadow-root reset to every subclass's styles, so no component
      * has to remember to include it, with the rules for the marks it writes.
@@ -312,7 +329,7 @@ export declare class HelixElement extends LitElement {
      * **Before the render, because `firstUpdated` is too late.** A value
      * assigned there schedules a second update as the first one finishes, which
      * Lit's development build reports as `change-in-update`: Command's
-     * `filterMatch` did in the Hartley app until October 14, 2026. A hydrating
+     * `filterMatch` did in a desktop app until October 14, 2026. A hydrating
      * render has to be the server's, so that element looks in `firstUpdated`,
      * where `finishHydration` asks for the update after it anyway.
      */

package/dist/helix-element/helix-element.js

@@ -7,6 +7,9 @@ const BOX_SIZING = '*,::before,::after{box-sizing:border-box}';
 const HIDDEN = ":host([hidden]:not([hidden='until-found'])){display:none}";
 const SETTLED = ':host(:not(:state(settled))),:host(:not(:state(settled))) *{transition:none!important}';
 const BASE = unsafeCSS(BOX_SIZING + HIDDEN + SETTLED);
+const attached = new WeakMap();
+export const internalsOf = (element) => attached.get(element);
+const LOWERED = new WeakMap();
 export class HelixElement extends LitElement {
     static { this.tier = 'helix-headless-'; }
     tag(name) {
@@ -22,8 +25,9 @@ export class HelixElement extends LitElement {
             : null;
     }
     toggleState(name, on) {
-        if ('states' in this.internals) {
-            this.internals.states[on ? 'add' : 'delete'](name);
+        const internals = internalsOf(this);
+        if ('states' in internals) {
+            internals.states[on ? 'add' : 'delete'](name);
         }
     }
     constructor() {
@@ -35,7 +39,7 @@ export class HelixElement extends LitElement {
                 event.stopPropagation();
             }
         };
-        this.internals = this.attachInternals();
+        attached.set(this, this.attachInternals());
         this.whenSettled = new Promise((resolve) => {
             this.resolveSettled = resolve;
         });
@@ -89,6 +93,24 @@ export class HelixElement extends LitElement {
         }));
     }
     static { this.markRules = []; }
+    static get observedAttributes() {
+        const attributes = super.observedAttributes;
+        const lowered = new Map();
+        for (const [name, options] of this.elementProperties) {
+            const attribute = options.attribute;
+            if (typeof name === 'string' && typeof attribute === 'string') {
+                const spelled = name.toLowerCase();
+                if (spelled !== attribute && !attributes.includes(spelled)) {
+                    lowered.set(spelled, attribute);
+                }
+            }
+        }
+        LOWERED.set(this, lowered);
+        return [...attributes, ...lowered.keys()];
+    }
+    attributeChangedCallback(name, old, value) {
+        super.attributeChangedCallback(LOWERED.get(this.constructor)?.get(name) ?? name, old, value);
+    }
     static finalizeStyles(styles) {
         const marks = this.markRules;
         return [

package/dist/helix-element/react-audit-off.d.ts

@@ -1,4 +1,4 @@
-import type { auditReactProps as audit } from './react-audit.js';
+import type { auditReactProps as audit, auditReactMissing as missing } from './react-audit.js';
 /**
  * The React prop audit in a production build: nothing.
  *
@@ -9,3 +9,5 @@ import type { auditReactProps as audit } from './react-audit.js';
  * `react-audit.ts`.
  */
 export declare const auditReactProps: typeof audit;
+/** The missing-props error in a production build: nothing. See `react-audit.ts`. */
+export declare const auditReactMissing: typeof missing;

package/dist/helix-element/react-audit-off.js

@@ -1 +1,2 @@
 export const auditReactProps = () => { };
+export const auditReactMissing = () => { };

package/dist/helix-element/react-audit.d.ts

@@ -18,3 +18,25 @@
  * binds it as an event named `:helix-open`.
  */
 export declare const auditReactProps: (host: EventTarget, props: Record<string, unknown>) => void;
+/**
+ * Says so when React has a root on the page and no element found its props.
+ *
+ * **The bridge's one silent failure.** It finds React's props by a prefix of
+ * React's own, so the day React renames that key every `onhelix-*` handler on
+ * a server-rendered page is dead again, and every object property a server
+ * dropped stays unset, with nothing in the console. The bridge calls this for
+ * an element whose window closed in a document carrying React's root mark,
+ * where no element has found a props bag, with the window it looked for and
+ * the mark, whose suffix is that React's own.
+ *
+ * **Only for an element React renders.** It has to sit in the document's own
+ * tree, never in a shadow root, which is where Lit renders most of this
+ * library's elements and where React holds nothing, and under the node React
+ * made its root in. A page whose React island renders no Helix element keeps
+ * its static ones outside that node, and is told nothing.
+ *
+ * **An error, once a page.** It means the elements cannot work with the React
+ * installed, which is a failure of the page rather than advice, and it is
+ * printed as `console.error` so a run that fails on the console fails here.
+ */
+export declare const auditReactMissing: (host: Node, window: number, mark: string) => void;

package/dist/helix-element/react-audit.js

@@ -1,6 +1,7 @@
 import { eventsForTag } from '../events/element-events.js';
 import { helixEventNames } from '../events/names.js';
 import { reportRuntime } from '../utils/report-runtime/report-runtime.js';
+import { insideReact } from './react-root.js';
 const audited = new WeakSet();
 const REMOVED = new Set(['onActiveChange', 'onCheckedChange', 'onOpenChange', 'onValueChange']);
 export const auditReactProps = (host, props) => {
@@ -54,3 +55,20 @@ export const auditReactProps = (host, props) => {
         }
     }
 };
+const told = new Set();
+export const auditReactMissing = (host, window, mark) => {
+    if (told.has(mark) || host.getRootNode() !== host.ownerDocument || !insideReact(host)) {
+        return;
+    }
+    told.add(mark);
+    reportRuntime({
+        kind: 'react-props-missing',
+        level: 'error',
+        message: `React has a root on this page, and no Helix element found the props React holds for it ` +
+            `within ${window} ms. Helix reads them under a key starting \`__reactProps$\`, and this ` +
+            'React no longer writes one. `onhelix-*` handlers on a server-rendered page will not run, and ' +
+            'object properties the server could not write will not arrive. Pin React to a version in the ' +
+            'range https://fusion.dev/helix/docs/using-the-elements states, and report the one installed.',
+        tag: host instanceof Element ? host.localName : undefined,
+    });
+};

package/dist/helix-element/react-bridge.d.ts

@@ -18,11 +18,44 @@ export declare const reactPropsOf: (node: EventTarget) => Record<string, unknown
  * set.
  */
 export declare const lookForReact: (host: LitElement, applied: boolean) => void;
+/**
+ * Resolves once React has hydrated an element, and soon after where React
+ * will not.
+ *
+ * **For a write onto markup a server rendered.** React compares a node's
+ * attributes with the server's as it begins hydrating that node, and writes
+ * the node's props as it completes it, after every node inside it. So once
+ * the element holds React's props, it and every node in it have been
+ * compared, and an attribute written then is no mismatch. Popover, Menu and
+ * Megamenu write `aria-expanded` onto a plain slotted trigger, and before
+ * October 25, 2026 they wrote it a frame after their first render. On a page
+ * whose definitions load before `hydrateRoot`, that frame came before React
+ * reached the trigger, and React reported "some attributes of the server
+ * rendered HTML didn't match the client properties", measured against React
+ * 19.3.1 with Megamenu and Popover.
+ *
+ * **A page whose mark has not arrived yet is waited for, for `LOOK_FOR`.** An
+ * app that defines the elements and calls `hydrateRoot` after a gap, an
+ * awaited import or a fetch, has no mark when the frame comes, and Megamenu
+ * and Popover were written to early on exactly such a page. So a page without
+ * the mark is looked at for the bridge's own window, and one that gains it is
+ * waited for as any other. A page that calls `hydrateRoot` later than that is
+ * still written to early, and a page without React pays the window once. On
+ * the site, which defers registration past hydration, React held the
+ * megamenu's props 7 to 33 ms after marking the page and 187 to 562 ms before
+ * the element's first frame, six loads, so it waits for nothing.
+ *
+ * Resolves for an element outside the node React renders into. Asked on the
+ * bridge's own interval, on a timer and never a frame, for the reason
+ * `LOOK_EVERY` gives.
+ */
+export declare const untilReactHydrated: (host: Element) => Promise<void>;
 /**
  * The prop React would be holding for this event, if it is holding one.
  *
  * **A relayed native event needs a different answer from one of ours, and
- * getting it wrong doubles every call.** Measured against React 19.2.8:
+ * getting it wrong doubles every call.** Measured against React 19.3.1 on
+ * October 25, 2026, on a client mount, as it was on 19.2.8 before it:
  *
  * ```
  * onhelix-before-change <- helix-before-change  REACHED (React binds it with addEventListener)

package/dist/helix-element/react-bridge.js

@@ -1,4 +1,5 @@
-import { auditReactProps } from '@fusion.dev/helix-core/audits/react';
+import { auditReactMissing, auditReactProps } from '@fusion.dev/helix-core/audits/react';
+import { insideReact } from './react-root.js';
 const REACT_PROPS = '__reactProps$';
 let reactPropsKey;
 export const reactPropsOf = (node) => {
@@ -15,17 +16,19 @@ export const reactPropsOf = (node) => {
 };
 const REACT_LISTENING = '_reactListening';
 const REACT_EVENTS = '__reactEvents$';
-const reactOnPage = (node) => Object.keys(node.ownerDocument ?? node).some((key) => key.startsWith(REACT_LISTENING) || key.startsWith(REACT_EVENTS));
+const reactMarkOf = (node) => Object.keys(node.ownerDocument ?? node).find((key) => key.startsWith(REACT_LISTENING) || key.startsWith(REACT_EVENTS));
 const LOOK_EVERY = 16;
 const LOOK_FOR = 96;
 const looking = [];
+const found = new Set();
 let ticks = 0;
 let booked = false;
-const take = (host, applied) => {
+const take = (host, applied, mark) => {
     const props = reactPropsOf(host);
     if (props === undefined) {
         return false;
     }
+    found.add(mark);
     if (!applied) {
         applyReactProperties(host);
     }
@@ -37,17 +40,20 @@ const tick = () => {
     ticks += 1;
     const now = performance.now();
     let page;
-    let react = false;
+    let mark;
     let kept = 0;
     for (const one of looking) {
         const own = one.host.ownerDocument ?? one.host;
         if (own !== page) {
             page = own;
-            react = reactOnPage(one.host);
+            mark = reactMarkOf(one.host);
         }
-        const done = (react && take(one.host, false)) ||
-            (ticks - one.after >= LOOK_FOR / LOOK_EVERY && now - one.since >= LOOK_FOR);
-        if (!done) {
+        const taken = mark !== undefined && take(one.host, false, mark);
+        const over = ticks - one.after >= LOOK_FOR / LOOK_EVERY && now - one.since >= LOOK_FOR;
+        if (!taken && over && mark !== undefined && !found.has(mark)) {
+            auditReactMissing(one.host, LOOK_FOR, mark);
+        }
+        if (!(taken || over)) {
             looking[kept] = one;
             kept += 1;
         }
@@ -62,11 +68,29 @@ const book = () => {
     }
 };
 export const lookForReact = (host, applied) => {
-    if (!(reactOnPage(host) && take(host, applied))) {
+    const mark = reactMarkOf(host);
+    if (!(mark !== undefined && take(host, applied, mark))) {
         looking.push({ after: ticks, host, since: performance.now() });
         book();
     }
 };
+const HYDRATION_BOUND = 5000;
+export const untilReactHydrated = (host) => new Promise((done) => {
+    const since = performance.now();
+    const look = () => {
+        const waited = performance.now() - since;
+        const marked = reactMarkOf(host) !== undefined;
+        if ((!marked && waited >= LOOK_FOR) ||
+            reactPropsOf(host) !== undefined ||
+            (marked && !insideReact(host)) ||
+            waited >= HYDRATION_BOUND) {
+            done();
+            return;
+        }
+        setTimeout(look, LOOK_EVERY);
+    };
+    look();
+});
 const REACT_WIRES = new Set(['scroll', 'scrollend']);
 export const reactPropFor = (event) => {
     if (event.type.includes('-')) {

package/dist/helix-element/react-root.d.ts

@@ -0,0 +1,2 @@
+/** Whether a node is in the tree React renders into, its root's container or below it. */
+export declare const insideReact: (host: Node) => boolean;

package/dist/helix-element/react-root.js

@@ -0,0 +1,9 @@
+const REACT_CONTAINER = '__reactContainer$';
+export const insideReact = (host) => {
+    for (let node = host.parentNode; node !== null; node = node.parentNode) {
+        if (Object.keys(node).some((key) => key.startsWith(REACT_CONTAINER))) {
+            return true;
+        }
+    }
+    return false;
+};

package/dist/helix-form-element/helix-form-element-base.js

@@ -1,6 +1,6 @@
 import { __decorate } from "tslib";
 import { property, state } from 'lit/decorators.js';
-import { HelixElement } from '../helix-element/helix-element.js';
+import { HelixElement, internalsOf } from '../helix-element/helix-element.js';
 import { watchLabels } from '../utils/watch-labels/watch-labels.js';
 const isTabStop = (element) => element instanceof HTMLElement &&
     element.tabIndex >= 0 &&
@@ -38,7 +38,7 @@ export class HelixFormElementBase extends HelixElement {
             }
         };
         this.refreshAnchor = () => {
-            if (!this.internals.validity.valid) {
+            if (!internalsOf(this).validity.valid) {
                 this.applyValidity();
             }
         };
@@ -67,22 +67,22 @@ export class HelixFormElementBase extends HelixElement {
         if (changed.get('disabled') === true && !this.disabled && this.isConnected) {
             this.formDisabled = this.heldByFieldset;
         }
-        this.internals.ariaDisabled = this.isDisabled ? 'true' : null;
+        internalsOf(this).ariaDisabled = this.isDisabled ? 'true' : null;
     }
     applyValidity() {
         if (this.customValidity === '') {
-            this.internals.setValidity({});
+            internalsOf(this).setValidity({});
             return;
         }
-        this.internals.setValidity({ customError: true }, this.customValidity, this.focusTarget ?? undefined);
+        internalsOf(this).setValidity({ customError: true }, this.customValidity, this.focusTarget ?? undefined);
     }
     get validity() {
         this.runPendingUpdate();
-        return this.internals.validity;
+        return internalsOf(this).validity;
     }
     get validationMessage() {
         this.runPendingUpdate();
-        return this.internals.validationMessage;
+        return internalsOf(this).validationMessage;
     }
     performUpdate() {
         this.updateRunning = true;
@@ -99,16 +99,16 @@ export class HelixFormElementBase extends HelixElement {
         }
     }
     get willValidate() {
-        return this.internals.willValidate;
+        return internalsOf(this).willValidate;
     }
     checkValidity() {
         this.runPendingUpdate();
-        return this.internals.checkValidity();
+        return internalsOf(this).checkValidity();
     }
     reportValidity() {
         this.runPendingUpdate();
         this.applyValidity();
-        return this.internals.reportValidity();
+        return internalsOf(this).reportValidity();
     }
     setCustomValidity(message) {
         this.customValidity = message;
@@ -150,10 +150,10 @@ export class HelixFormElementBase extends HelixElement {
         this.click();
     }
     get form() {
-        return this.internals.form;
+        return internalsOf(this).form;
     }
     get labels() {
-        return this.internals.labels;
+        return internalsOf(this).labels;
     }
 }
 __decorate([

package/dist/helix-form-element/helix-form-element.js

@@ -1,3 +1,4 @@
+import { internalsOf } from '../helix-element/helix-element.js';
 import { HelixFormElementBase } from './helix-form-element-base.js';
 const VALIDITY_FLAGS = [
     'badInput',
@@ -50,7 +51,7 @@ export class HelixFormElement extends HelixFormElementBase {
         this.reported = { anchor: undefined, flags: {}, message: '' };
         this.appliedFeedback = '';
         this.checkInProgress = false;
-        const internals = this.internals;
+        const internals = internalsOf(this);
         const report = internals.setValidity.bind(internals);
         this.reportValidityTo = report;
         internals.setValidity = (flags, message, anchor) => {
@@ -90,7 +91,7 @@ export class HelixFormElement extends HelixFormElementBase {
         this.runPendingUpdate();
         this.checkInProgress = true;
         try {
-            return this.internals.checkValidity();
+            return internalsOf(this).checkValidity();
         }
         finally {
             this.checkInProgress = false;
@@ -101,7 +102,7 @@ export class HelixFormElement extends HelixFormElementBase {
     }
     connectedCallback() {
         super.connectedCallback();
-        watchFormChecks(this.internals.form);
+        watchFormChecks(internalsOf(this).form);
     }
     formAssociatedCallback(form) {
         watchFormChecks(form);

package/dist/index.d.ts

@@ -41,9 +41,11 @@ export { UpgradeController, type UpgradeOptions, } from './controllers/upgrade-c
 export { type Rendered, VirtualizeController, type VirtualizeOptions, type Window as VirtualizeWindow, } from './controllers/virtualize-controller/virtualize-controller.js';
 export { Waterfall } from './controllers/virtualize-controller/waterfall.js';
 export { eventsForTag, registerElementEvents } from './events/element-events.js';
-export { type ActivateDetail, type AuraFallbackDetail, type BandDetail, type CanvasView, type CaretDetail, type ChangeDetail, type CompleteDetail, type ConnectDetail, type ConsoleDetail, type CopyDetail, type CreateDetail, type DeviceButton, type DeviceButtonDetail, type DeviceKeyDetail, type DeviceScrollDetail, type DeviceSwipeDetail, type DeviceTapDetail, type DeviceTextDetail, type DeviceTouchDetail, type DismissDetail, type FacetDetail, type FilterDetail, type FoundDetail, type GraphFilterDetail, type GraphLayoutDetail, type GraphPartChangeDetail, type GraphSignalDetail, HelixActionEvent, HelixActivateEvent, HelixAuraFallbackEvent, HelixBandEvent, HelixBeforeActivateEvent, HelixBeforeChangeEvent, HelixBeforeCloseEvent, HelixBeforeCollapseEvent, HelixBeforeEditEvent, HelixBeforeListenEvent, HelixBeforeMoveEvent, HelixBeforeOpenEvent, HelixBeforePanelResizeEvent, HelixBeforePasteEvent, HelixBeforePinEvent, HelixBeforeReconnectEvent, HelixBeforeRelabelEvent, HelixBeforeReorderEvent, HelixBeforeResizeEvent, HelixBeforeSplitEvent, HelixBeforeToggleEvent, HelixCanvasEditEvent, HelixCanvasPanEvent, HelixCanvasViewEvent, HelixCanvasZoomEvent, HelixCaretEvent, HelixClearEvent, HelixCollapseEvent, HelixCompleteEvent, HelixConnectEvent, HelixConsoleEvent, HelixCopyErrorEvent, HelixCopyEvent, HelixCreateEvent, HelixDeviceButtonEvent, HelixDeviceKeyEvent, HelixDeviceScreenshotEvent, HelixDeviceScrollEvent, HelixDeviceSwipeEvent, HelixDeviceTapEvent, HelixDeviceTextEvent, HelixDeviceTouchEvent, HelixDismissEvent, HelixEditEvent, HelixEndEvent, HelixExpandEvent, HelixFacetEvent, HelixFilterEvent, HelixFilteredEvent, HelixFoundEvent, HelixGraphFilterEvent, HelixGraphLayoutEvent, HelixGraphPanEvent, HelixGraphPartChangeEvent, HelixGraphReadyEvent, HelixGraphSignalEvent, HelixGraphZoomEvent, HelixHistoryEvent, HelixListenEvent, HelixLoadEvent, HelixLoadMoreEvent, HelixMapClusterEvent, HelixMapPanEvent, HelixMapPartChangeEvent, HelixMapReadyEvent, HelixMapRotateEvent, HelixMapTiltEvent, HelixMapZoomEvent, HelixMoveEvent, HelixNavigateEvent, HelixNextEvent, HelixPanelResizeEvent, HelixPastedEvent, HelixPinEvent, HelixPlotChangeEvent, HelixPlotTurnEvent, HelixPressEvent, HelixPreviewEvent, HelixPreviousEvent, HelixRangeChangeEvent, HelixReadEvent, HelixReadingChangeEvent, HelixReadingPressEvent, HelixReconnectEvent, HelixRejectEvent, HelixRelabelEvent, HelixRemoveEvent, HelixReorderEvent, HelixReorderedEvent, HelixResizedEvent, HelixResizeEvent, HelixSampleEndEvent, HelixSampleStartEvent, HelixScrolledEvent, HelixSelectEvent, HelixSelectedEvent, HelixSendEvent, HelixShortcutEvent, HelixSortEvent, HelixSortedEvent, HelixSplitEvent, HelixStopEvent, HelixStrandsFallbackEvent, HelixTerminalBellEvent, HelixTerminalInputEvent, HelixTerminalLinkEvent, HelixTerminalResizeEvent, HelixTerminalRestartEvent, HelixTerminalTitleEvent, HelixToggleEvent, HelixTourAskEvent, HelixTourStatusEvent, HelixTypingEvent, type ListenDetail, type MapClusterDetail, type MapPanDetail, type MapPartChangeDetail, type MapRotateDetail, type MapTiltDetail, type MapZoomDetail, type MoveDetail, type NavigateDetail, type OpenDetail, type PasteDetail, type PlotChangeDetail, type PlotTurnDetail, type PressDetail, type PressPointerType, type RangeDetail, type ReadDetail, type ReadingDetail, type ReconnectDetail, type Refusal, type RefusedFile, type RejectDetail, type RelabelDetail, type RemoveDetail, type ReorderDetail, type ResizeDetail, type ScrolledDetail, type SelectDetail, type SendDetail, type ShortcutDetail, type SkipDetail, type SortDetail, type StrandsFallbackDetail, type TerminalInputDetail, type TerminalLinkDetail, type TerminalResizeDetail, type TerminalTitleDetail, type ToggleDetail, type TourStatusDetail, type TypingDetail, type ViewportPanDetail, type ViewportZoomDetail, } from './events/events.js';
-export { HelixElement, whenHydrated } from './helix-element/helix-element.js';
+export { type ActivateDetail, type ChangeDetail, type CheckDetail, type CompleteDetail, type CopyDetail, type DismissDetail, type FilterDetail, type FoundDetail, HelixActivateEvent, HelixBeforeActivateEvent, HelixBeforeChangeEvent, HelixBeforeCheckEvent, HelixBeforeCloseEvent, HelixBeforeFilterEvent, HelixBeforeListenEvent, HelixBeforeNavigateEvent, HelixBeforeOpenEvent, HelixBeforePinEvent, HelixBeforeReorderEvent, HelixBeforeResizeEvent, HelixBeforeSelectEvent, HelixBeforeSortEvent, HelixCheckEvent, HelixClearEvent, HelixCompleteEvent, HelixCopyErrorEvent, HelixCopyEvent, HelixDismissEvent, HelixExpandEvent, HelixFilterEvent, HelixFoundEvent, HelixListenEvent, HelixLoadEvent, HelixLoadMoreEvent, HelixNavigateEvent, HelixPinEvent, HelixPlotChangeEvent, HelixPlotTurnEvent, HelixReadingChangeEvent, HelixReadingPressEvent, HelixReorderEvent, HelixResizedEvent, HelixResizeEvent, HelixSelectEvent, HelixSortEvent, type ListenDetail, type NavigateDetail, type OpenDetail, type PlotChangeDetail, type PlotTurnDetail, type PressPointerType, type ReadingDetail, type ReorderDetail, type ResizeDetail, type SelectDetail, type SortDetail, type ViewportPanDetail, type ViewportZoomDetail, } from './events/events.js';
+export { helixEventNames, registerEventNames } from './events/names.js';
+export { HelixElement, internalsOf, whenHydrated } from './helix-element/helix-element.js';
 export { LAYERS_RULE, MIRROR_RULE, SCROLLER_RULE, SPOKEN_RULE, TOUCHES_RULE, VIRTUAL_RULE, } from './helix-element/mark-rules.js';
+export { untilReactHydrated } from './helix-element/react-bridge.js';
 export { HelixFormElement } from './helix-form-element/helix-form-element.js';
 export { HelixFormElementBase } from './helix-form-element/helix-form-element-base.js';
 export { MixinChartSource, type MixinChartSourceInterface, PALETTE, PLOT_HEIGHT, PLOT_WIDTH, POSITION_LABEL, READINGS_PAGE, seriesIndex, seriesNames, } from './mixins/mixin-chart-source/mixin-chart-source.js';

package/dist/index.js

@@ -41,9 +41,11 @@ export { UpgradeController, } from './controllers/upgrade-controller/upgrade-con
 export { VirtualizeController, } from './controllers/virtualize-controller/virtualize-controller.js';
 export { Waterfall } from './controllers/virtualize-controller/waterfall.js';
 export { eventsForTag, registerElementEvents } from './events/element-events.js';
-export { HelixActionEvent, HelixActivateEvent, HelixAuraFallbackEvent, HelixBandEvent, HelixBeforeActivateEvent, HelixBeforeChangeEvent, HelixBeforeCloseEvent, HelixBeforeCollapseEvent, HelixBeforeEditEvent, HelixBeforeListenEvent, HelixBeforeMoveEvent, HelixBeforeOpenEvent, HelixBeforePanelResizeEvent, HelixBeforePasteEvent, HelixBeforePinEvent, HelixBeforeReconnectEvent, HelixBeforeRelabelEvent, HelixBeforeReorderEvent, HelixBeforeResizeEvent, HelixBeforeSplitEvent, HelixBeforeToggleEvent, HelixCanvasEditEvent, HelixCanvasPanEvent, HelixCanvasViewEvent, HelixCanvasZoomEvent, HelixCaretEvent, HelixClearEvent, HelixCollapseEvent, HelixCompleteEvent, HelixConnectEvent, HelixConsoleEvent, HelixCopyErrorEvent, HelixCopyEvent, HelixCreateEvent, HelixDeviceButtonEvent, HelixDeviceKeyEvent, HelixDeviceScreenshotEvent, HelixDeviceScrollEvent, HelixDeviceSwipeEvent, HelixDeviceTapEvent, HelixDeviceTextEvent, HelixDeviceTouchEvent, HelixDismissEvent, HelixEditEvent, HelixEndEvent, HelixExpandEvent, HelixFacetEvent, HelixFilterEvent, HelixFilteredEvent, HelixFoundEvent, HelixGraphFilterEvent, HelixGraphLayoutEvent, HelixGraphPanEvent, HelixGraphPartChangeEvent, HelixGraphReadyEvent, HelixGraphSignalEvent, HelixGraphZoomEvent, HelixHistoryEvent, HelixListenEvent, HelixLoadEvent, HelixLoadMoreEvent, HelixMapClusterEvent, HelixMapPanEvent, HelixMapPartChangeEvent, HelixMapReadyEvent, HelixMapRotateEvent, HelixMapTiltEvent, HelixMapZoomEvent, HelixMoveEvent, HelixNavigateEvent, HelixNextEvent, HelixPanelResizeEvent, HelixPastedEvent, HelixPinEvent, HelixPlotChangeEvent, HelixPlotTurnEvent, HelixPressEvent, HelixPreviewEvent, HelixPreviousEvent, HelixRangeChangeEvent, HelixReadEvent, HelixReadingChangeEvent, HelixReadingPressEvent, HelixReconnectEvent, HelixRejectEvent, HelixRelabelEvent, HelixRemoveEvent, HelixReorderEvent, HelixReorderedEvent, HelixResizedEvent, HelixResizeEvent, HelixSampleEndEvent, HelixSampleStartEvent, HelixScrolledEvent, HelixSelectEvent, HelixSelectedEvent, HelixSendEvent, HelixShortcutEvent, HelixSortEvent, HelixSortedEvent, HelixSplitEvent, HelixStopEvent, HelixStrandsFallbackEvent, HelixTerminalBellEvent, HelixTerminalInputEvent, HelixTerminalLinkEvent, HelixTerminalResizeEvent, HelixTerminalRestartEvent, HelixTerminalTitleEvent, HelixToggleEvent, HelixTourAskEvent, HelixTourStatusEvent, HelixTypingEvent, } from './events/events.js';
-export { HelixElement, whenHydrated } from './helix-element/helix-element.js';
+export { HelixActivateEvent, HelixBeforeActivateEvent, HelixBeforeChangeEvent, HelixBeforeCheckEvent, HelixBeforeCloseEvent, HelixBeforeFilterEvent, HelixBeforeListenEvent, HelixBeforeNavigateEvent, HelixBeforeOpenEvent, HelixBeforePinEvent, HelixBeforeReorderEvent, HelixBeforeResizeEvent, HelixBeforeSelectEvent, HelixBeforeSortEvent, HelixCheckEvent, HelixClearEvent, HelixCompleteEvent, HelixCopyErrorEvent, HelixCopyEvent, HelixDismissEvent, HelixExpandEvent, HelixFilterEvent, HelixFoundEvent, HelixListenEvent, HelixLoadEvent, HelixLoadMoreEvent, HelixNavigateEvent, HelixPinEvent, HelixPlotChangeEvent, HelixPlotTurnEvent, HelixReadingChangeEvent, HelixReadingPressEvent, HelixReorderEvent, HelixResizedEvent, HelixResizeEvent, HelixSelectEvent, HelixSortEvent, } from './events/events.js';
+export { helixEventNames, registerEventNames } from './events/names.js';
+export { HelixElement, internalsOf, whenHydrated } from './helix-element/helix-element.js';
 export { LAYERS_RULE, MIRROR_RULE, SCROLLER_RULE, SPOKEN_RULE, TOUCHES_RULE, VIRTUAL_RULE, } from './helix-element/mark-rules.js';
+export { untilReactHydrated } from './helix-element/react-bridge.js';
 export { HelixFormElement } from './helix-form-element/helix-form-element.js';
 export { HelixFormElementBase } from './helix-form-element/helix-form-element-base.js';
 export { MixinChartSource, PALETTE, PLOT_HEIGHT, PLOT_WIDTH, POSITION_LABEL, READINGS_PAGE, seriesIndex, seriesNames, } from './mixins/mixin-chart-source/mixin-chart-source.js';