@fusion.dev/helix-headless 0.13.2 → 0.15.0

package/custom-elements.json

@@ -13878,7 +13878,7 @@
               "name": "listbox-search-field"
             },
             {
-              "description": "The count of choices held beyond `max-tags`.",
+              "description": "The count of choices held beyond `max-tags`. A `<button>` with `expandable`, a `<span>` without it.",
               "name": "rest"
             },
             {
@@ -14432,6 +14432,48 @@
                 "text": "toggleOpen() => boolean"
               }
             },
+            {
+              "kind": "field",
+              "name": "collapseLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show fewer'",
+              "description": "What the control says once everything is showing.",
+              "attribute": "collapse-label",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "expandable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the count is a control that shows the rest.",
+              "attribute": "expandable",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "expandLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show all'",
+              "description": "What the collapsed count is called, since `+3` names nothing.",
+              "attribute": "expand-label",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
             {
               "kind": "field",
               "name": "maxTags",
@@ -14446,6 +14488,44 @@
                 "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "expanded",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the reader has asked for all of them.\n\nState and private, the way `Input`'s `revealed` is: it is a reader's\nmomentary choice about what is on their own screen, it must not survive\nanything, and a consumer who wants the field opened is asking for\n`max-tags=\"0\"` rather than for a second way to say it.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "shownLimit",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "toggleExpanded",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Turns the cap off and on, which is all expanding is.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "renderTokenRow",
@@ -14474,6 +14554,29 @@
                 "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
               }
             },
+            {
+              "kind": "method",
+              "name": "renderRest",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "over",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "The count, as a control where the host asked for one and a word otherwise.\n\n**`part=\"rest\"` either way**, so a consumer's `::part(rest)` keeps working\nacross the change. The element under it is different, which is the point:\na `<span>` that looks like an affordance and answers nothing is the fault\nthis exists to fix, and the way to fix it is a real button rather than a\nclick handler on text.\n\n**Expanded, it renders on no count.** `shownLimit` is zero while expanded,\nso `over` is zero too, and gating the control on the number would take\naway the only way back.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "hideOverflow",
@@ -15385,6 +15488,45 @@
                 "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
               }
             },
+            {
+              "name": "collapse-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show fewer'",
+              "description": "What the control says once everything is showing.",
+              "fieldName": "collapseLabel",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "name": "expandable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the count is a control that shows the rest.",
+              "fieldName": "expandable",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "name": "expand-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show all'",
+              "description": "What the collapsed count is called, since `+3` names nothing.",
+              "fieldName": "expandLabel",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
             {
               "name": "max-tags",
               "type": {
@@ -26496,7 +26638,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "**The tokens are the consumer's own elements, slotted.** What a filter narrows\nby belongs to the consumer's model rather than to this element: a facet with a\nprefix, a saved query, a range. So they are slotted rather than rendered from\na list of strings, and removing one is a request this element makes rather\nthan a change it applies. Combobox is the other way round, and that is the\ndifference between the two: its tokens are a view of a selection it owns,\ndrawn from options it was handed.\n\n**`value` is the text being typed, not the tokens**, which is what makes this\na field a consumer can listen to. Every keystroke announces `input` with the\ntext on the element, so a table narrows as the reader types. The tokens need\nno reporting back, being markup the consumer already holds.\n\nBackspace on an empty field asks the last token to go, through the same\n`helix-dismiss` its own remove control fires, so a consumer who handled the\npointer has already handled the keyboard.",
+          "description": "**The tokens are the consumer's own elements, slotted.** What a filter narrows\nby belongs to the consumer's model rather than to this element: a facet with a\nprefix, a saved query, a range. So they are slotted rather than rendered from\na list of strings, and removing one is a request this element makes rather\nthan a change it applies. Combobox is the other way round, and that is the\ndifference between the two: its tokens are a view of a selection it owns,\ndrawn from options it was handed.\n\n**`value` is the text being typed, not the tokens**, which is what makes this\na field a consumer can listen to. Every keystroke announces `input` with the\ntext on the element, so a table narrows as the reader types. The tokens need\nno reporting back, being markup the consumer already holds.\n\nBackspace on an empty field asks the last token to go, through the same\n`helix-dismiss` its own remove control fires, so a consumer who handled the\npointer has already handled the keyboard.\n\n**It can suggest what to type next, and it never learns the grammar.** Slot\n`helix-option` elements into `suggestions` and the field shows them, moves\nthrough them with the arrows, and lets Enter press one; the option fires its\nown `helix-select` and the consumer decides what choosing meant. Deciding\n*what* to suggest is theirs too: keys before a colon and values after it are\nthe same panel with different contents, which is all a two-level filter is,\nand the parse that tells them apart belongs where the domain does.\n\n**The panel opens when there is something in it and closes when there is\nnot**, rather than on a choice. A reader who picks a key wants its values\nnext, and closing on the choice would shut the panel between two renders. Use\n`selectionStart` and `setSelectionRange` to write a completion back and put\nthe caret after it, or the next parse reads the wrong term.",
           "name": "HelixHeadlessFilterInput",
           "cssParts": [
             {
@@ -26524,9 +26666,13 @@
               "name": "label"
             },
             {
-              "description": "How many tokens did not fit.",
+              "description": "How many tokens did not fit. A `<button>` with `expandable`, a `<span>` without it.",
               "name": "rest"
             },
+            {
+              "description": "The floating panel the suggestions sit in.",
+              "name": "surface"
+            },
             {
               "description": "The row the tokens sit in.",
               "name": "tags"
@@ -26541,6 +26687,10 @@
               "description": "Before the text, for a search icon.",
               "name": "start"
             },
+            {
+              "description": "What could be typed next, as `Option`s, and `Option.Group`s of them.",
+              "name": "suggestions"
+            },
             {
               "description": "What is already narrowing the results, as `Tag`s.",
               "name": "tags"
@@ -26609,6 +26759,43 @@
               "default": "0",
               "description": "How many tokens did not fit, which is what the row's count renders."
             },
+            {
+              "kind": "field",
+              "name": "activeAt",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "-1",
+              "description": "Which suggestion the keyboard is on, or `-1` for none.\n\nAn index rather than a value, unlike Listbox's: these are the consumer's\nown list and two of them may legitimately carry the same value, a `label`\nand an `assignee` both called `ada`. Position is what a reader is moving\nthrough and it is what stays right when they do."
+            },
+            {
+              "kind": "field",
+              "name": "suggesting",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether anything is offering itself to be suggested.\n\n**The ARIA follows this rather than being declared once.** A text field\ncarrying `role=\"combobox\"` promises a popup; a filter field that no consumer\never gives options to has none, and saying otherwise sends a screen reader\nlooking for a list that does not exist. So the role, `aria-expanded` and\n`aria-controls` all arrive with the first option and leave with the last."
+            },
+            {
+              "kind": "field",
+              "name": "dismissed",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether Escape has closed the panel over text that still has suggestions.\n\nWithout it the panel is open whenever there is something to show, so Escape\nwould close it and the next render would put it straight back. Cleared by\nthe next keystroke, because that is the reader saying something new."
+            },
+            {
+              "kind": "field",
+              "name": "panel",
+              "privacy": "protected",
+              "readonly": true,
+              "default": "new PopoverController(this, { anchor: () => this.renderRoot?.querySelector<HTMLElement>('[part=\"field\"]'), boundary: (): readonly (Element | null | undefined)[] => [ this.renderRoot?.querySelector<HTMLElement>('[part=\"surface\"]'), this.renderRoot?.querySelector<HTMLElement>('[part=\"field\"]'), ], offset: () => 4, onDismiss: () => this.requestOpen(false), placement: 'bottom-start', surface: () => this.renderRoot?.querySelector<HTMLElement>('[part=\"surface\"]'), })"
+            },
             {
               "kind": "field",
               "name": "releaseCaret",
@@ -26658,56 +26845,111 @@
             },
             {
               "kind": "field",
-              "name": "handleInput",
+              "name": "suggestions",
+              "type": {
+                "text": "SuggestionOption[]"
+              },
               "privacy": "private",
-              "readonly": true,
-              "description": "Every keystroke, cancelable, and put back where it is refused.\n\nStopped for the reason `Input` gives: `input` is composed, so the inner\ncontrol's own would arrive beside the one the mixin announces and a consumer\nwould hear one keystroke twice, once carrying the value from before it."
+              "description": "The suggestions, in the order a reader moves through them.\n\n**Groups are opened out rather than walked into.** A slot assigns the group\nelement, not the options inside it, so a panel that read only what was\nassigned would offer nothing at all the moment a consumer reached for\n`option-group` to say what a run of values belongs to.\n\nA disabled option keeps its place on screen and is skipped here, which is\nthe difference between a list that explains why something cannot be chosen\nand one that pretends it was never there.",
+              "readonly": true
             },
             {
               "kind": "field",
-              "name": "handleChange",
-              "privacy": "private",
-              "readonly": true,
-              "description": "Relayed, because `change` does not cross a shadow boundary on its own."
+              "name": "selectionDirection",
+              "type": {
+                "text": "'backward' | 'forward' | 'none'"
+              },
+              "description": "The caret and the selection, under the platform's own names.\n\n**Published for the reason `Input` publishes them, and this element needs\nthem more.** The `<input>` is inside this shadow root, so a consumer has no\nway to ask where the caret is: `querySelector` does not cross the boundary.\nA grammar that completes what is being typed cannot work without it, because\n\"what is being typed\" is the term the caret is in, and after writing a\ncompletion back the caret has to be put after it or the next parse reads the\nwrong term.\n\nZero before there is a control, which is where an empty field's caret would\nbe anyway.",
+              "readonly": true
             },
             {
               "kind": "field",
-              "name": "handleClear",
+              "name": "selectionEnd",
+              "type": {
+                "text": "number"
+              },
+              "description": "Where the selection ends, which is the caret when nothing is selected.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "selectionStart",
+              "type": {
+                "text": "number"
+              },
+              "description": "Where the selection starts, which is the caret when nothing is selected.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "setSelectionRange",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "start",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "end",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "direction",
+                  "optional": true,
+                  "type": {
+                    "text": "'backward' | 'forward' | 'none'"
+                  }
+                }
+              ],
+              "description": "Moves the caret, or selects a run of the text.",
+              "type": {
+                "text": "setSelectionRange(start: number, end: number, direction?: 'backward' | 'forward' | 'none') => void"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "handleInput",
               "privacy": "private",
               "readonly": true,
-              "description": "Empties the text and gives the caret back.\n\nFocus returns to the input rather than staying on a button that is about to\ndisappear, which would otherwise land on the body."
+              "description": "Every keystroke, cancelable, and put back where it is refused.\n\nStopped for the reason `Input` gives: `input` is composed, so the inner\ncontrol's own would arrive beside the one the mixin announces and a consumer\nwould hear one keystroke twice, once carrying the value from before it."
             },
             {
               "kind": "field",
-              "name": "handleKeydown",
+              "name": "handleChange",
               "privacy": "private",
-              "readonly": true
+              "readonly": true,
+              "description": "Relayed, because `change` does not cross a shadow boundary on its own."
             },
             {
               "kind": "field",
-              "name": "handleTokens",
+              "name": "handleClear",
               "privacy": "private",
               "readonly": true,
-              "description": "The row again, whenever what is in it changes."
+              "description": "Empties the text and gives the caret back.\n\nFocus returns to the input rather than staying on a button that is about to\ndisappear, which would otherwise land on the body."
             },
             {
               "kind": "method",
-              "name": "removeLastToken",
-              "privacy": "protected",
+              "name": "settleOpen",
+              "privacy": "private",
               "return": {
                 "type": {
                   "text": "void"
                 }
               },
-              "description": "Asks the last token to go, rather than taking it.\n\n`dismiss()` is the tag's own, so this is the code path its remove control\nalready runs on a press: the consumer hears one `helix-dismiss`, cancels it\nor removes the element, and never learns which of the two asked. A slotted\nnode that is not a `Tag` has no such method and is left alone, because\nhiding a consumer's element on Backspace would be this element deciding\nsomething it was never given.",
-              "inheritedFrom": {
-                "name": "MixinTokens",
-                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
-              }
+              "description": "Opens the panel when there is something in it, and closes it when there is\nnot.\n\n**Derived rather than commanded, which is the whole of how two levels\nwork.** A reader who picks `disposition` wants its values next, and the\nconsumer answers by rendering those values; if picking closed the panel it\nwould shut and reopen between two renders, which a reader sees as a flicker\nand a screen reader hears as a list going away. Nothing here closes on a\nchoice: the panel goes when the consumer stops offering, which is exactly\nwhen a value has been completed and there is nothing left to say.\n\nThrough `requestOpen` for both directions, so `helix-before-open` and\n`helix-before-close` still gate it and a consumer who refuses is obeyed.\n**No guard of its own**, because that method already returns early when the\nanswer has not moved: this runs after every render, and a second guard here\nwould only be a copy of that one going stale."
             },
             {
               "kind": "method",
-              "name": "focus",
+              "name": "move",
+              "privacy": "private",
               "return": {
                 "type": {
                   "text": "void"
@@ -26715,33 +26957,308 @@
               },
               "parameters": [
                 {
-                  "name": "options",
-                  "optional": true,
+                  "name": "by",
                   "type": {
-                    "text": "FocusOptions"
+                    "text": "number"
                   }
                 }
               ],
-              "description": "Puts the caret in the field, the way a label pointing at one would.",
-              "type": {
-                "text": "focus(options?: FocusOptions) => void"
-              }
+              "description": "Moves the highlight, wrapping, and opens the panel if it was closed."
             },
             {
               "kind": "field",
-              "name": "maxTags",
-              "type": {
-                "text": "number"
-              },
-              "default": "0",
-              "description": "How many tokens to show before the rest become a count.",
-              "attribute": "max-tags",
-              "inheritedFrom": {
-                "name": "MixinTokens",
-                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
-              }
-            },
-            {
+              "name": "handleKeydown",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "refreshSuggesting",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "What is on offer, settled before the render that draws it.\n\n**Not left to `slotchange`, for the reason the token row is not.** That\nevent reports the assignment moving and nothing else, and it does not fire\nat all under the harness these are tested in, so a panel that learned only\nfrom it would be a panel that never opened. Reading the slot every update is\nwhat makes the answer true whenever anyone asks.\n\nState only. Opening is an announcement and belongs after the render, which\nis why `settleOpen` is not called from here."
+            },
+            {
+              "kind": "field",
+              "name": "handleSuggestions",
+              "privacy": "private",
+              "readonly": true,
+              "description": "The panel again, whenever what is in it changes."
+            },
+            {
+              "kind": "field",
+              "name": "handleFocusIn",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Focus arriving in the field is a reader asking what they can type."
+            },
+            {
+              "kind": "field",
+              "name": "handleFocusOut",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Focus leaving the element closes it.\n\n`relatedTarget` and not a timer: a press inside the panel moves focus within\nthis element and must not close what is being pressed."
+            },
+            {
+              "kind": "field",
+              "name": "handleTokens",
+              "privacy": "private",
+              "readonly": true,
+              "description": "The row again, whenever what is in it changes."
+            },
+            {
+              "kind": "method",
+              "name": "removeLastToken",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks the last token to go, rather than taking it.\n\n`dismiss()` is the tag's own, so this is the code path its remove control\nalready runs on a press: the consumer hears one `helix-dismiss`, cancels it\nor removes the element, and never learns which of the two asked. A slotted\nnode that is not a `Tag` has no such method and is left alone, because\nhiding a consumer's element on Backspace would be this element deciding\nsomething it was never given.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "markActive",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Marks the highlighted suggestion, and tells the control which one it is.\n\n**Two halves, and neither does the other's job.** `active` is the option's\nown published flag and is what a stylesheet draws from. The control carries\n`aria-activedescendant`, because focus never leaves the text: a screen\nreader is told what is highlighted by the field the caret is in, not by the\nlist.\n\nThrough `ariaActiveDescendantElement` rather than an id, which is what\n`Listbox` reaches for and for the same two reasons: it crosses a shadow\nboundary, where an `aria-activedescendant` naming an id cannot, and it needs\nno ids invented for the consumer's own elements. Feature-tested, because\nwhere it is missing the assignment is a silent no-op rather than an error,\nand the highlight is still drawn."
+            },
+            {
+              "kind": "method",
+              "name": "focus",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "FocusOptions"
+                  }
+                }
+              ],
+              "description": "Puts the caret in the field, the way a label pointing at one would.",
+              "type": {
+                "text": "focus(options?: FocusOptions) => void"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "open",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the element is open.\n\nOne property, not two, so `dialog.open` answers the question anyone\nasking it meant. Writing always applies; `<helix-dialog open>` is the\nsame statement in markup.\n\n**Not reflected, and that is required rather than tidy.** Reflection\nwrites the resolved state back as an attribute, so an element that opened\nitself would put `open` on its own host: cloned, serialized for\nhydration, or diffed by a framework, it comes back holding whatever the\nlast reader did rather than what the author wrote. `:state(open)` carries\nthe resolved state for stylesheets, which is what the mirror is for.",
+              "attribute": "open",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "defaultOpen",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Initial open state for uncontrolled use, where nothing declared one.",
+              "attribute": "default-open",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "openState",
+              "type": {
+                "text": "boolean | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "The state, whoever set it, and `undefined` until somebody has.\n\nPrefixed, and it has to be. These mixins compose onto one prototype\nchain, `Select` takes this one and `MixinControllerValue` together, and\nTypeScript's `private` is a compile-time fiction: two mixins with a field\ncalled `state` share one property on the instance, and the second one\nsilently overwrites the first. Measured, as a select whose `value` came\nback holding its `open` boolean.\n\nOne field and not two. Writing always applies, the way a native control\ndoes when a script assigns to it.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "requestOpen",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Requests an open-state change, and reports whether it was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-open` or\n`helix-before-close` is a refusal and nothing moves. Nobody refusing means the\nelement opens or closes itself, whether or not a consumer declared\n`open`: a declared property is a seed and a correction, and a consumer\nwho wants the decision for themselves refuses it and assigns their own.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              },
+              "type": {
+                "text": "requestOpen(next: boolean) => boolean"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "announceToggle",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "open",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Says the state moved, under the platform's own name and in its shape.\n\n**A native `toggle` from inside a shadow root reaches nobody**, because\nit neither bubbles nor composes, so the ten families showing a\n`popover=\"manual\"` panel and the two rendering a real `<dialog>` announce\nnothing to a consumer. The disclosures have no native element to fire\nanything at all: `AccordionItem` and `TreeItem` are `aria-expanded` and\n`hidden` written by hand, which is `<details>`'s job done manually.\n\n**From here rather than from `PopoverController`.** The controller covers\neleven families and the mixin covers sixteen, so announcing from both\nwould announce twice on the ten they share. What `toggle` reports is the\n*state*, and the state is this mixin's; the controller is a way of\nputting a panel on the screen.\n\n**`newState` and `oldState`, because that is the platform's shape**, so a\nconsumer arriving from `<details>` reads the same two words. Not\ncancelable: the before events are the request, and a second cancelable\nevent for one transition is two answers to one question.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleOpen",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Requests the opposite of the current state.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              },
+              "type": {
+                "text": "toggleOpen() => boolean"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "collapseLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show fewer'",
+              "description": "What the control says once everything is showing.",
+              "attribute": "collapse-label",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "expandable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the count is a control that shows the rest.",
+              "attribute": "expandable",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "expandLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show all'",
+              "description": "What the collapsed count is called, since `+3` names nothing.",
+              "attribute": "expand-label",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "maxTags",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "How many tokens to show before the rest become a count.",
+              "attribute": "max-tags",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "expanded",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the reader has asked for all of them.\n\nState and private, the way `Input`'s `revealed` is: it is a reader's\nmomentary choice about what is on their own screen, it must not survive\nanything, and a consumer who wants the field opened is asking for\n`max-tags=\"0\"` rather than for a second way to say it.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "shownLimit",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "toggleExpanded",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Turns the cap off and on, which is all expanding is.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
               "kind": "method",
               "name": "renderTokenRow",
               "privacy": "protected",
@@ -26769,6 +27286,29 @@
                 "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
               }
             },
+            {
+              "kind": "method",
+              "name": "renderRest",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "over",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "The count, as a control where the host asked for one and a word otherwise.\n\n**`part=\"rest\"` either way**, so a consumer's `::part(rest)` keeps working\nacross the change. The element under it is different, which is the point:\na `<span>` that looks like an affordance and answers nothing is the fault\nthis exists to fix, and the way to fix it is a real button rather than a\nclick handler on text.\n\n**Expanded, it renders on no count.** `shownLimit` is zero while expanded,\nso `over` is zero too, and gating the control on the number would take\naway the only way back.",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
             {
               "kind": "method",
               "name": "hideOverflow",
@@ -27487,6 +28027,22 @@
               "name": "helix-before-change",
               "reactProp": "onhelix-before-change"
             },
+            {
+              "type": {
+                "text": "HelixBeforeCloseEvent"
+              },
+              "description": "Fired before the suggestions go, and cancelable.",
+              "name": "helix-before-close",
+              "reactProp": "onhelix-before-close"
+            },
+            {
+              "type": {
+                "text": "HelixBeforeOpenEvent"
+              },
+              "description": "Fired before the suggestions show, and cancelable.",
+              "name": "helix-before-open",
+              "reactProp": "onhelix-before-open"
+            },
             {
               "name": "input",
               "type": {
@@ -27498,6 +28054,14 @@
                 "module": "src/mixins/mixin-controller-value/mixin-controller-value.ts"
               },
               "reactProp": "oninput"
+            },
+            {
+              "type": {
+                "text": "Event"
+              },
+              "description": "Says the panel moved, carrying `newState` and `oldState`.",
+              "name": "toggle",
+              "reactProp": "ontoggle"
             }
           ],
           "attributes": [
@@ -27528,6 +28092,70 @@
               "description": "Shown while the field is empty.\n\nNot a label: it goes when typing starts.",
               "fieldName": "placeholder"
             },
+            {
+              "name": "open",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the element is open.\n\nOne property, not two, so `dialog.open` answers the question anyone\nasking it meant. Writing always applies; `<helix-dialog open>` is the\nsame statement in markup.\n\n**Not reflected, and that is required rather than tidy.** Reflection\nwrites the resolved state back as an attribute, so an element that opened\nitself would put `open` on its own host: cloned, serialized for\nhydration, or diffed by a framework, it comes back holding whatever the\nlast reader did rather than what the author wrote. `:state(open)` carries\nthe resolved state for stylesheets, which is what the mirror is for.",
+              "fieldName": "open",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "name": "default-open",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Initial open state for uncontrolled use, where nothing declared one.",
+              "fieldName": "defaultOpen",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "name": "collapse-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show fewer'",
+              "description": "What the control says once everything is showing.",
+              "fieldName": "collapseLabel",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "name": "expandable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the count is a control that shows the rest.",
+              "fieldName": "expandable",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
+            {
+              "name": "expand-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Show all'",
+              "description": "What the collapsed count is called, since `+3` names nothing.",
+              "fieldName": "expandLabel",
+              "inheritedFrom": {
+                "name": "MixinTokens",
+                "module": "src/mixins/mixin-tokens/mixin-tokens.ts"
+              }
+            },
             {
               "name": "max-tags",
               "type": {
@@ -27646,6 +28274,10 @@
             }
           ],
           "mixins": [
+            {
+              "name": "MixinControllerOpen",
+              "package": "@fusion.dev/helix-core"
+            },
             {
               "name": "MixinTokens",
               "package": "@fusion.dev/helix-core"