@fusion.dev/helix-core 0.0.0-dev

package/dist/events/events.js

@@ -0,0 +1,799 @@
+/**
+ * Event classes, one per event a Helix component dispatches.
+ *
+ * A named class rather than `dispatchEvent(new CustomEvent(name, …))` for three
+ * reasons, all of them about the type reaching a consumer:
+ *
+ * 1. `@event {HelixBeforeOpenEvent} helix-before-open` puts the class name in the manifest,
+ *    which is what lets the React generator emit a typed callback instead of
+ *    `(detail: unknown)`.
+ * 2. The augmentation of `HTMLElementEventMap` below types `addEventListener`
+ *    for consumers writing plain HTML, who never see the React wrappers.
+ * 3. The event name lives on the class as `eventName`, so a listener and a
+ *    dispatch cannot disagree about the string.
+ */
+/**
+ * Fired when an element is about to open.
+ *
+ * Cancelable: `preventDefault()` refuses the change, and the element stays
+ * closed. Paired with `helix-before-close` rather than being one event carrying a
+ * boolean, so a listener that only cares about one direction says so by which
+ * event it listens for.
+ *
+ * Neither bubbles nor composed. A dialog inside a drawer inside a popover is
+ * three overlays, and an inner one opening must not read as the outer one
+ * opening.
+ */
+export class HelixBeforeOpenEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-open'; }
+    constructor() {
+        super(HelixBeforeOpenEvent.eventName, {
+            bubbles: false,
+            cancelable: true,
+            composed: false,
+            detail: { open: true },
+        });
+    }
+}
+/** Fired when an element is about to close. See `HelixBeforeOpenEvent`. */
+export class HelixBeforeCloseEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-close'; }
+    constructor() {
+        super(HelixBeforeCloseEvent.eventName, {
+            bubbles: false,
+            cancelable: true,
+            composed: false,
+            detail: { open: false },
+        });
+    }
+}
+/**
+ * Fired when the reader asks for the next thing in a set.
+ *
+ * Paired with `helix-previous` rather than being one event carrying a
+ * direction, which is the reason `helix-before-open` gives for its own pair: a
+ * listener that only cares about one direction says so by which event it
+ * listens for. The detail carries the direction anyway, so a consumer who does
+ * want one handler can have one.
+ *
+ * Bubbles and is composed, because the thing that answers this is usually not
+ * the thing that asked. A video has no notion of a set: it plays one resource,
+ * and what comes next is a playlist's business or the consumer's, so the event
+ * has to reach a wrapper.
+ *
+ * Not cancelable. There is no default action to refuse: the component that
+ * fires this does nothing on its own, and an event whose `preventDefault` means
+ * nothing is an event that lies about what it offers.
+ */
+export class HelixNextEvent extends CustomEvent {
+    static { this.eventName = 'helix-next'; }
+    constructor() {
+        super(HelixNextEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail: { to: 'next' },
+        });
+    }
+}
+/** Fired when the reader asks for the previous one. See `HelixNextEvent`. */
+export class HelixPreviousEvent extends CustomEvent {
+    static { this.eventName = 'helix-previous'; }
+    constructor() {
+        super(HelixPreviousEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail: { to: 'previous' },
+        });
+    }
+}
+/**
+ * A stop asking the tour to move.
+ *
+ * Composed and bubbling, because a stop is slotted into the root and the root
+ * has to hear it across that boundary.
+ *
+ * **A class rather than the raw `CustomEvent` this was.** It dispatched, it
+ * bubbled, and it was invisible: `check:events` matches `new HelixSomethingEvent(`,
+ * so a hand-rolled `CustomEvent` was not held to being declared, and nothing
+ * carried it into the manifest. Consumers could hear it and could not find it,
+ * which is the trap #75 is about, in its purest form.
+ */
+export class HelixTourAskEvent extends CustomEvent {
+    static { this.eventName = 'helix-tour-ask'; }
+    constructor(detail) {
+        super(HelixTourAskEvent.eventName, {
+            bubbles: true,
+            /* Not cancelable, and this is the one of the four where that was a real
+               promise rather than an idle flag. The name says *ask*, so a consumer had
+               every reason to think refusing it held the tour, and the root's
+               `handleAsk` never read `defaultPrevented`: the tour moved anyway.
+               Honoring it there would not have worked either, and the reason is
+               ordering. The root registers its listener in `connectedCallback` and a
+               consumer registers later, so on a bubbling event both are on the same
+               target and the root's runs first: it would read `defaultPrevented`
+               before the consumer had a chance to set it. `helix-shortcut` gets this
+               right by reading the flag on the element that dispatched, where every
+               listener has already run.
+      
+               **The veto exists and is elsewhere**, which is why this is a
+               downgrade rather than a gap. Moving between stops goes through
+               `requestChange` and announces `helix-before-activate`; leaving early
+               dispatches `helix-before-close` and reads the flag before writing
+               `open`. Both are honored. This event is the stop telling the root a
+               button was pressed, and the decision is taken one step later. */
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * The eyedropper opening, and closing again.
+ *
+ * Two events rather than one carrying a flag, because what a consumer does with
+ * them is not symmetrical: the surface holding the picker has to get out of the
+ * way for the sample and come back afterwards, and those are two moments with
+ * different work in each.
+ *
+ * **A class rather than the bare `Event` these were.** They dispatched, they
+ * bubbled, `ColorInput` bound both, and `check:events` matched
+ * `new CustomEvent(` and so held neither to being declared: two pieces of
+ * public API that a consumer could hear and could not find. The check reads
+ * `new Event(` now as well.
+ *
+ * No detail, because there is nothing to say beyond that it happened.
+ */
+export class HelixSampleStartEvent extends Event {
+    static { this.eventName = 'helix-sample-start'; }
+    constructor() {
+        super(HelixSampleStartEvent.eventName, { bubbles: true, cancelable: false, composed: true });
+    }
+}
+/** The eyedropper closing, whether or not a color was taken. */
+export class HelixSampleEndEvent extends Event {
+    static { this.eventName = 'helix-sample-end'; }
+    constructor() {
+        super(HelixSampleEndEvent.eventName, { bubbles: true, cancelable: false, composed: true });
+    }
+}
+/**
+ * Fired when an element asks to be taken away.
+ *
+ * A request rather than a notification: the element does not remove itself,
+ * because the consumer owns the markup it is in and removing the node under
+ * them would put their state and the document out of step. Cancelable, so
+ * `preventDefault()` is a refusal.
+ *
+ * One verb for both shapes. A tag leaving a list and an announcement closing
+ * itself are the same act from the element's side.
+ */
+export class HelixDismissEvent extends CustomEvent {
+    static { this.eventName = 'helix-dismiss'; }
+    constructor(detail) {
+        super(HelixDismissEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * A set is about to make a different child current, and can be refused.
+ *
+ * **The generic `helix-change` covered this and should not have.** Eleven
+ * families that are not form controls announced their state under the word the
+ * platform uses for a committed value, which is 294's whole complaint read from
+ * the other end: `Tabs` moving to another tab, `Tree` marking another row and
+ * `Steps` advancing are not a value changing, they are a set choosing. One word
+ * for four questions is what `appearance` was before `check:axes`.
+ *
+ * `active` names which child is current, so `activate` is the verb, and unlike
+ * `change` the platform has no claim on it.
+ *
+ * **It has a notification half now, and this said it did not.** *Reversed 28 Aug
+ * 2026.* The paragraph here read "there is no notification half: a native
+ * `change` would be a lie about what moved, and no other native event means
+ * this. The before event is the whole channel." The first half of that is still
+ * exactly right, which is why the pair is `helix-activate` and not `change`. The
+ * conclusion did not follow: that no *native* word fits is an argument against
+ * borrowing one, not an argument against having a notification at all.
+ *
+ * What the missing half cost is the thing 294 fixed for values and left here.
+ * A consumer who only wants to know which child is current now had one channel,
+ * and it fires *before* `apply`: `currentTarget.active` still holds the previous
+ * value inside the handler, and `detail.value` is a proposal another listener may
+ * refuse. Measured across the four families taking this mixin, nothing at all was
+ * announced afterwards. `Tabs` and `Tree` looked covered because `helix-select`
+ * bubbles up from a child, which fires when an item is *chosen* and not when
+ * `active` is assigned; `Steps` and `Video Playlist` had nothing.
+ *
+ * So the shape is the one `MixinControllerOpen` already has, a cancelable
+ * request and a plain notification after the state has moved. See #325.
+ */
+export class HelixBeforeActivateEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-activate'; }
+    constructor(detail) {
+        super(HelixBeforeActivateEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * A set has made a different child current.
+ *
+ * The notification half of `helix-before-activate`, dispatched after the state
+ * has moved, so `currentTarget.active` is the new value and the detail is a fact
+ * rather than a proposal.
+ *
+ * **Not cancelable**, for the reason every notification here is not: the
+ * decision was taken by the event before it, and a second refusable event for
+ * one transition is two answers to one question.
+ *
+ * **Prefixed, and it has to be.** `activate` unprefixed is not in any
+ * `*EventMap` in the DOM library, checked rather than assumed, but the prefix is
+ * what stops an event dispatched inside a shadow root and retargeted to the host
+ * being mistaken for something the host's own contents sent. That is the same
+ * argument `helix-select` and `helix-resize` are excused under.
+ */
+export class HelixActivateEvent extends CustomEvent {
+    static { this.eventName = 'helix-activate'; }
+    constructor(detail) {
+        super(HelixActivateEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/** A message is about to be pinned or unpinned, and can be refused. */
+export class HelixBeforePinEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-pin'; }
+    constructor(detail) {
+        super(HelixBeforePinEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/** A divider is about to move, and can be refused. */
+export class HelixBeforeResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-resize'; }
+    constructor(detail) {
+        super(HelixBeforeResizeEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * The divider between a sandbox's panes is about to move, and can be refused.
+ *
+ * Its own verb rather than a `helix-before-resize` carrying which divider moved:
+ * a sandbox has two, and they were told apart by a field on a detail every other
+ * request in this file also carries. See 306.
+ */
+export class HelixBeforeSplitEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-split'; }
+    constructor(detail) {
+        super(HelixBeforeSplitEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * A sandbox's panel is about to change height, and can be refused.
+ *
+ * The sibling of `helix-before-split`, and named for the divider rather than for
+ * the axis because a reader binding one of the two is choosing which divider they
+ * care about. `value` is pixels here and a percentage there, which is what each
+ * property already publishes.
+ */
+export class HelixBeforePanelResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-panel-resize'; }
+    constructor(detail) {
+        super(HelixBeforePanelResizeEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/** A pane is about to collapse or reopen, and can be refused. */
+export class HelixBeforeCollapseEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-collapse'; }
+    constructor(detail) {
+        super(HelixBeforeCollapseEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/** Source is about to be edited, and can be refused. */
+export class HelixBeforeEditEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-edit'; }
+    constructor(detail) {
+        super(HelixBeforeEditEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * A value is about to change, and the change can be refused.
+ *
+ * **The request half of every value control.** It announces the value being
+ * *proposed*, before anything moves, so a listener calling `preventDefault()`
+ * refuses it and the control stays where it was. That is how a consumer takes
+ * one decision without declaring a mode, which is what 294 settled: the element
+ * always owns and applies its state, and refusing is the way to take it over.
+ *
+ * **The notification is native and separate.** Once this has gone out and the
+ * value has moved, the control announces it again under the platform's own
+ * name, `input` while a reader is editing and `change` when they are done, so
+ * `onChange` in React and `onchange=` in HTML both reach it and
+ * `currentTarget.value` is correct by the time a handler reads it. This event
+ * carries the detail because at the moment it fires the value is not on the
+ * element yet.
+ *
+ * **It replaced `helix-change` and `helix-input` on the value controls**, which
+ * were one mechanism under two names chosen by `announcesInput`. The name said
+ * *phase* and the flag meant *granularity*, so a consumer reading "change" as
+ * "the reader is done" wired a request to `onhelix-change` and got one per
+ * character. Granularity is now what the platform already says it is, `input`
+ * against `change`, and `announcesInput` picks which native one fires rather
+ * than which name this carries. See 294.
+ */
+export class HelixBeforeChangeEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-change'; }
+    constructor(detail) {
+        super(HelixBeforeChangeEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * A checked state is about to change, and the change can be refused.
+ *
+ * **Its own event rather than a `helix-before-change` carrying a boolean**, and
+ * the reason is recorded rather than aesthetic. Reported through the value
+ * event the state arrived as `String(checked)`, so a consumer received the
+ * string `"false"`, which is truthy, and this library's own checkbox group
+ * decoded it with `detail.value === 'true'`. A test asserting the value would
+ * have passed on that bug. A control whose state is a boolean wants an event
+ * with a typed boolean in it.
+ *
+ * The notification is native, as it is for a value: the control relays `change`
+ * from the inner input and announces `input` beside it, so `onChange` reads
+ * `currentTarget.checked` and gets a boolean from the platform.
+ *
+ * It also ends a collision. Checkbox Group listened for its boxes' change and
+ * dispatched its own under the same name from the same host, so it had to call
+ * `stopImmediatePropagation` to keep a consumer from receiving one box's
+ * boolean alongside the whole set. Two names, two facts.
+ */
+export class HelixBeforeToggleEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-toggle'; }
+    constructor(detail) {
+        super(HelixBeforeToggleEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * The reader asked for something the list does not hold.
+ *
+ * Cancelable, and announced before anything is applied, because the options are
+ * the consumer's own light DOM and no component here writes into it. What the
+ * control can do is say what was asked for and take the value; putting an
+ * option in the list, or a row in a database, is the consumer's, and a consumer
+ * who validates first refuses this and adds nothing.
+ *
+ * The detail carries the text as typed, not a slug of it. Trimming or lowering
+ * it here would be this element deciding what a name means, and a consumer who
+ * wants an identifier can make one from what they were given.
+ */
+export class HelixCreateEvent extends CustomEvent {
+    static { this.eventName = 'helix-create'; }
+    constructor(detail) {
+        super(HelixCreateEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Something was copied to the clipboard.
+ *
+ * Not cancelable, and deliberately: it is announced after the write, because a
+ * clipboard write is a permission the platform may refuse and there is nothing
+ * useful to report until it has either happened or not.
+ */
+export class HelixCopyEvent extends CustomEvent {
+    static { this.eventName = 'helix-copy'; }
+    constructor(detail) {
+        super(HelixCopyEvent.eventName, {
+            bubbles: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when something being previewed writes to the console.
+ *
+ * Carries text rather than the logged values. The preview is a separate
+ * document, so what arrives has crossed `postMessage` and been through
+ * structured clone: a DOM node or a function does not survive that, and half a
+ * value is worse than a string of it.
+ */
+export class HelixConsoleEvent extends CustomEvent {
+    static { this.eventName = 'helix-console'; }
+    constructor(detail) {
+        super(HelixConsoleEvent.eventName, {
+            bubbles: true,
+            /* Not cancelable, for the reason `helix-resize` is not: a log line the
+               frame already wrote is a fact being relayed, and this element's own
+               comment at the dispatch says "relayed rather than acted on". Nothing
+               read the result. */
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when something reports how much room its content actually needs.
+ *
+ * **A measurement crossing a boundary the measurer is on the far side of.** A
+ * sandboxed preview is its own document: nothing outside it can read the height
+ * of what it drew, because the frame is opaque and a box sized from the outside
+ * only ever reports the box. So the document measures itself and says so, and
+ * this is what it says it with.
+ *
+ * A number rather than a box, because the width is the container's to decide and
+ * only the block size follows the content. A consumer that wants to act on it
+ * clamps it: what arrives is what was drawn, which for an empty example is
+ * nearly nothing and for a long one is more than a page.
+ */
+export class HelixResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-resize'; }
+    constructor(detail) {
+        super(HelixResizeEvent.eventName, {
+            bubbles: true,
+            /* Not cancelable, and it was until 27 Aug 2026. A measurement is not a
+               proposal: the content is that tall whether or not anybody wants it to
+               be, and neither dispatcher, `Heatmap` nor `Sandbox.Preview`, ever read
+               the result. So `preventDefault()` on it was accepted and ignored, which
+               is worse than refusing the call: a consumer had every reason to believe
+               they had stopped something. */
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when a header crosses the threshold between resting at the top of the
+ * page and floating over it.
+ *
+ * **State a consumer used to read off an attribute, said out loud instead.**
+ * The header reflected this as `data-scrolled` on its own host, which is an
+ * attribute nobody rendered: a server sends the element without it and the
+ * element adds it on upgrade, so a framework hydrating the page finds markup
+ * that no longer matches what it sent. The threshold now lives in a custom
+ * state, which is deliberately not in the DOM and therefore not something a
+ * hydration pass can disagree with.
+ *
+ * That closes the observability the attribute accidentally provided. A
+ * `MutationObserver` can watch an attribute and there is no equivalent for
+ * `ElementInternals.states`, so a component holding a boolean nothing can read
+ * is a component with a private opinion its consumers demonstrably need: the
+ * bar's own backdrop is drawn by the page around it, and the page has to know
+ * when to light it.
+ *
+ * Not cancelable. It reports where the page is rather than asking permission to
+ * be there, and refusing it would leave the state and the announcement
+ * disagreeing.
+ *
+ * The hysteresis stays inside the header, which is the point of announcing at
+ * all: a consumer listening to `scroll` itself would be a second opinion on
+ * when the page counts as scrolled, and the two would part company at the eight
+ * pixels of travel this waits for.
+ */
+export class HelixScrolledEvent extends CustomEvent {
+    static { this.eventName = 'helix-scrolled'; }
+    constructor(detail) {
+        super(HelixScrolledEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when the cursor moves in a text editor.
+ *
+ * Not cancelable, unlike everything else here. The others announce something
+ * about to happen and a listener can refuse it; this one reports where the
+ * caret already is, and there is nothing left to refuse.
+ *
+ * It fires on every keystroke and every arrow press, which is why the status
+ * bar reads it from the DOM rather than through a framework's state: routing a
+ * caret position through React would re-render the workbench on every cursor
+ * move.
+ */
+export class HelixCaretEvent extends CustomEvent {
+    static { this.eventName = 'helix-caret'; }
+    constructor(detail) {
+        super(HelixCaretEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when a component moves the view it is showing, rather than its value.
+ *
+ * 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.
+ */
+export class HelixNavigateEvent extends CustomEvent {
+    static { this.eventName = 'helix-navigate'; }
+    constructor(detail) {
+        super(HelixNavigateEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when a control that fills up has filled.
+ *
+ * The moment a code entry exists for: a six-character field is worth submitting
+ * the instant the sixth character lands, and a consumer watching `helix-change`
+ * has to know the length and compare it on every keystroke to find that moment
+ * themselves.
+ *
+ * Separate from `helix-change` rather than a flag on it, because they are
+ * answered by different code: one keeps a value in step and the other decides
+ * whether to send a form. A listener that only cares about the second says so by
+ * which event it listens for.
+ *
+ * `complete` is free as a verb. React's synthetic system claims `change`,
+ * `input`, `submit`, `reset`, `copy`, `paste`, `scroll`, `drag`, `focus` and
+ * `blur`, measured, and this is none of them.
+ *
+ * Not cancelable. It reports that something already happened, which is the same
+ * reason `helix-caret` is not: there is nothing left to refuse once the last
+ * character is in the box.
+ */
+export class HelixCompleteEvent extends CustomEvent {
+    static { this.eventName = 'helix-complete'; }
+    constructor(detail) {
+        super(HelixCompleteEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when the reader offers something they wrote.
+ *
+ * **Cancelable, and the composer clears only when nobody refused.** Sending is a
+ * round trip: a composer that empties itself and then hears the request failed
+ * has thrown away the only copy of what the reader typed, and a reader who has
+ * just written three paragraphs is exactly who cannot afford that. Refusing
+ * leaves the text where it is.
+ *
+ * Not `helix-create`, which is the combobox's event for a value a list does not
+ * hold, and not `helix-change`, because nothing about a value changed: the
+ * reader finished something and handed it over.
+ */
+export class HelixSendEvent extends CustomEvent {
+    static { this.eventName = 'helix-send'; }
+    constructor(detail) {
+        super(HelixSendEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when something a user comes back to is marked read, or unread.
+ *
+ * **Read state is reported rather than owned.** Marking a notification read is
+ * usually a round trip, and a component that flips the state itself and then
+ * hears the request failed has already told the reader something untrue. So this
+ * is cancelable, and refusing it leaves the item alone; a component left
+ * uncontrolled applies it once nobody has refused, which is the same contract
+ * every other axis in the library uses.
+ *
+ * Bubbles and is composed, so a feed hears its own items: one handler on the
+ * list serves every notification in it, which is what a consumer syncing to a
+ * server actually wants.
+ */
+export class HelixReadEvent extends CustomEvent {
+    static { this.eventName = 'helix-read'; }
+    constructor(detail) {
+        super(HelixReadEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when the reader asks for 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. In controlled mode nothing is written whatever the
+ * answer, and this is the element reporting that a heading was clicked.
+ *
+ * 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.
+ */
+export class HelixSortEvent extends CustomEvent {
+    static { this.eventName = 'helix-sort'; }
+    constructor(detail) {
+        super(HelixSortEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when a component narrows what it is showing.
+ *
+ * Filtering hides rather than removes, so nothing about the value changes and
+ * `helix-change` would be a lie. What a consumer wants to know is that the list
+ * in front of the reader is no longer the whole list.
+ */
+export class HelixFilterEvent extends CustomEvent {
+    static { this.eventName = 'helix-filter'; }
+    constructor(detail) {
+        super(HelixFilterEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when a shortcut's chord is pressed.
+ *
+ * Cancelable, and the key event is only consumed where this is not refused: a
+ * consumer that decides the moment is wrong, a dialog is over the control or
+ * the reader is mid-composition, calls `preventDefault()` and the keystroke
+ * goes on to whatever would have had it.
+ */
+export class HelixShortcutEvent extends CustomEvent {
+    static { this.eventName = 'helix-shortcut'; }
+    constructor(detail) {
+        super(HelixShortcutEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Fired when the reader selects an item in a set.
+ *
+ * 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.
+ */
+export class HelixSelectEvent extends CustomEvent {
+    static { this.eventName = 'helix-select'; }
+    constructor(detail) {
+        super(HelixSelectEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}
+/**
+ * Every event this file publishes, and the one place a new one is added.
+ *
+ * The map below is derived from this rather than written beside it. Kept by
+ * hand, the two drifted: `helix-filter` and `helix-navigate` were dispatched by
+ * the calendar, the listbox and the pagination and were missing from the map
+ * for weeks, so the one thing the augmentation exists to do was not done for
+ * them and a consumer writing `addEventListener('helix-navigate', …)` got
+ * `Event` and had to reach into `detail` through a cast. Nothing failed, which
+ * is why two of the nine went missing.
+ *
+ * Derived, a class that is in here is typed and a class that is not is absent
+ * from both halves at once, so the two cannot disagree. `check:events` fails
+ * the build on an exported event class left out of this object, which is the
+ * only step left that can be forgotten.
+ */
+const registry = {
+    HelixActivateEvent,
+    HelixBeforeActivateEvent,
+    HelixBeforeChangeEvent,
+    HelixBeforeCloseEvent,
+    HelixBeforeCollapseEvent,
+    HelixBeforeEditEvent,
+    HelixBeforeOpenEvent,
+    HelixBeforePanelResizeEvent,
+    HelixBeforePinEvent,
+    HelixBeforeResizeEvent,
+    HelixBeforeSplitEvent,
+    HelixBeforeToggleEvent,
+    HelixCaretEvent,
+    HelixCompleteEvent,
+    HelixConsoleEvent,
+    HelixCopyEvent,
+    HelixCreateEvent,
+    HelixDismissEvent,
+    HelixFilterEvent,
+    HelixNavigateEvent,
+    HelixNextEvent,
+    HelixPreviousEvent,
+    HelixReadEvent,
+    HelixResizeEvent,
+    HelixSampleEndEvent,
+    HelixSampleStartEvent,
+    HelixScrolledEvent,
+    HelixSelectEvent,
+    HelixSendEvent,
+    HelixShortcutEvent,
+    HelixSortEvent,
+    HelixTourAskEvent,
+};
+/**
+ * Every name this library dispatches.
+ *
+ * Exported so a runtime check can ask whether a name is one of ours without
+ * keeping a second list of them. `HelixElement` uses it to tell a consumer that
+ * the handler prop they wrote is attached to nothing.
+ */
+export const helixEventNames = new Set(Object.values(registry).map((event) => event.eventName));