@fusion.dev/helix-headless 0.101.0 → 0.103.0

package/custom-elements.json

@@ -46674,6 +46674,14 @@
             "module": "src/loader/index.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/map/index.js"
+          }
+        },
         {
           "kind": "js",
           "name": "*",
@@ -55414,6 +55422,812 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/map/index.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "HelixHeadlessMap",
+          "declaration": {
+            "name": "HelixHeadlessMap",
+            "module": "./root/map-root.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/map/root/map-root.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "**Helix draws no map.** There are no tiles here, no projection and no\nnetwork, and there should not be: a tile renderer is a library, and what a\ndesign system can add to MapLibre or Leaflet is the frame. The consumer slots\ntheir map and this owns the box, the name, the controls and the way out,\nwhich is the shape `VideoPlaylist` uses for a player it never renders.\n\n**The accessibility argument is the reason this exists**, and it was measured\nrather than assumed: a map embedded the ordinary way is a canvas with no role\nand no name, and it has *no node at all* in the accessibility tree. A reader\nusing a screen reader does not walk past it so much as never meet it. A named\nregion with controls in it is the whole of the difference.\n\n**The controls are buttons, and that is a deliberate choice against arrow\nkeys.** Arrows work here too, but what a screen reader does with them is not\nours to decide: macOS passes them through, Windows readers hold them for\ntheir own reading mode unless a page takes `role=\"application\"`, which costs\nthe reader their normal way of reading everything else in the frame. A button\nis findable and operable in every screen reader on every platform without\nthat bargain, so panning and zooming are buttons first and keys second.\n\n**Nothing here moves the map.** Both controls ask, through `helix-map-pan`\nand `helix-map-zoom`, and the consumer answers against whatever they slotted.\nA frame that moved the map would have to know whose map it was.",
+          "name": "HelixHeadlessMap",
+          "cssParts": [
+            {
+              "description": "The group the pan and zoom buttons sit in.",
+              "name": "controls"
+            },
+            {
+              "description": "The button that fills the screen.",
+              "name": "fullscreen"
+            },
+            {
+              "description": "The button that moves the map down.",
+              "name": "pan-down"
+            },
+            {
+              "description": "The button that moves the map the way the text ends, which is right on an English page.",
+              "name": "pan-end"
+            },
+            {
+              "description": "The button that moves the map the way the text starts, which is left on an English page.",
+              "name": "pan-start"
+            },
+            {
+              "description": "The button that moves the map up.",
+              "name": "pan-up"
+            },
+            {
+              "description": "The named region the map is slotted into.",
+              "name": "region"
+            },
+            {
+              "description": "The box the map is drawn in.",
+              "name": "viewport"
+            },
+            {
+              "description": "The button that zooms in.",
+              "name": "zoom-in"
+            },
+            {
+              "description": "The button that zooms out.",
+              "name": "zoom-out"
+            }
+          ],
+          "slots": [
+            {
+              "description": "The map, which is the consumer's own.",
+              "name": ""
+            },
+            {
+              "description": "Whoever the tiles belong to, which most licenses require you to say.",
+              "name": "attribution"
+            },
+            {
+              "description": "Chrome below the map, such as a legend or a scale.",
+              "name": "footer"
+            },
+            {
+              "description": "Chrome above the map, such as a title or a search field.",
+              "name": "header"
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "controls",
+              "type": {
+                "text": "string | undefined"
+              },
+              "description": "Which of the controls this frame draws, as a list of what to keep.\n\n**A list rather than a switch, because the overlap is not symmetric.**\nEvery map library draws zoom controls and none of them draws pan buttons:\nMapLibre's navigation control is zoom and a compass, Leaflet's is zoom,\nGoogle's is zoom. So a consumer slotting one of those has our zoom twice\nover and our pan pad not at all, and a single switch would make them choose\nbetween a duplicate and nothing.\n\n`none` draws none of them, which is the right answer where the slotted map\nalready has controls a reader can find: what this family argues for is that\n*a* findable control exists, never that it is ours. The methods stay public\neither way, so a consumer drawing their own chrome can still drive the\nframe.\n\nAbsent is all three, which is this library's rule that a resting value is an\nattribute's absence, and it is what the stylesheet asks about: the layout\nrules are written against `[controls]:not([controls~=\"zoom\"])` rather than\nthe bare negation, or a frame that named no list at all would be laid out as\nthough it had dropped everything.",
+              "attribute": "controls",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "controlsPlacement",
+              "type": {
+                "text": "'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | undefined"
+              },
+              "description": "Which corner the controls sit in.\n\n**Configurable because there is no safe default**, and this is a collision\nrather than a taste: MapLibre puts its own controls at the top end, Leaflet\nand OpenLayers at the top start, Google's zoom at the bottom end. Whichever\ncorner this took would land on somebody's, which is why every one of those\nlibraries made it a setting too.\n\nLogical corners rather than left and right, so a right-to-left page moves\nthem without a consumer writing a second rule.\n\nAbsent is the top end, which is this library's rule that a resting value is\nan attribute's absence: a default that reflected would write an attribute\nonto every host that no server sent and nobody asked for.",
+              "attribute": "controls-placement",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "fullscreenLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Fill the screen'",
+              "description": "What the control that fills the screen is called.",
+              "attribute": "fullscreen-label"
+            },
+            {
+              "kind": "field",
+              "name": "idleDelay",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "How long the reader may be still before the chrome hides, in milliseconds.\n\nZero keeps it up, which is the default: a map's controls are how a keyboard\nreader operates it, and chrome that hides itself by default would be this\ncomponent undoing its own argument. Set it for a display map nobody drives.",
+              "attribute": "idle-delay"
+            },
+            {
+              "kind": "field",
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Accessible name for the map, which is the one thing a consumer must write.\n\nThere is no sensible default. \"Map\" names the widget rather than the place,\nand a reader meeting three of them on a page learns nothing from hearing the\nsame word three times.",
+              "attribute": "label"
+            },
+            {
+              "kind": "field",
+              "name": "panLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Pan {way}'",
+              "description": "What the controls are called, for a page not in English.",
+              "attribute": "pan-label"
+            },
+            {
+              "kind": "field",
+              "name": "panStep",
+              "type": {
+                "text": "number"
+              },
+              "default": "0.25",
+              "description": "How far one press moves the map, as a fraction of what is on screen.\n\nA fraction rather than a distance, because this frame does not know the\nscale of what is inside it: a quarter of the viewport is the same gesture at\nstreet level and at country level, and a consumer who wants metres can\nmultiply by their own.",
+              "attribute": "pan-step"
+            },
+            {
+              "kind": "field",
+              "name": "zoomInLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Zoom in'",
+              "description": "What the zoom controls are called.",
+              "attribute": "zoom-in-label"
+            },
+            {
+              "kind": "field",
+              "name": "zoomOutLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Zoom out'",
+              "description": "What the zoom control that goes the other way is called.",
+              "attribute": "zoom-out-label"
+            },
+            {
+              "kind": "field",
+              "name": "resting",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the reader has been still long enough to hide the chrome."
+            },
+            {
+              "kind": "field",
+              "name": "filled",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the frame is filling the screen."
+            },
+            {
+              "kind": "field",
+              "name": "fullscreen",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new FullscreenController(this, (full) => { this.filled = full })"
+            },
+            {
+              "kind": "field",
+              "name": "idle",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new IdleController( this, () => this.idleDelay, (resting) => { this.resting = resting }, )"
+            },
+            {
+              "kind": "method",
+              "name": "draws",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "group",
+                  "type": {
+                    "text": "'pan' | 'zoom' | 'fullscreen'"
+                  }
+                }
+              ],
+              "description": "Whether a named group of controls is one this frame draws."
+            },
+            {
+              "kind": "method",
+              "name": "toggleFullscreen",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Fills the screen with the frame, or comes back.",
+              "type": {
+                "text": "toggleFullscreen() => void"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "pan",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "to",
+                  "type": {
+                    "text": "Way"
+                  }
+                }
+              ],
+              "description": "Asks for the map to move, which the consumer answers.",
+              "type": {
+                "text": "pan(to: Way) => void"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "zoom",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "by",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Asks for the map to zoom, `1` in and `-1` out.",
+              "type": {
+                "text": "zoom(by: number) => void"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "handleKeydown",
+              "privacy": "private",
+              "readonly": true,
+              "description": "The arrow keys, which are the second way rather than the only one.\n\n`inlineStep` rather than a test against `ArrowLeft`, so the reader on a\nright-to-left page gets `end` from the key that points the way their text\nruns, which is what the pan buttons say too."
+            },
+            {
+              "kind": "method",
+              "name": "named",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "way",
+                  "type": {
+                    "text": "Way"
+                  }
+                }
+              ],
+              "description": "What one pan button is called, with the way it goes filled in.\n\nLeft and right rather than start and end, because the label is read aloud\nand a reader knows which way left is. The event keeps the reading-order\nname, which is the one a right-to-left page needs."
+            },
+            {
+              "kind": "method",
+              "name": "renderControls",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The controls, or nothing where a consumer kept none of them.\n\n**Written out rather than generated**, because a part name behind an\ninterpolation is a part the manifest cannot see: it would publish `pan-`\nand a consumer's `::part(pan-up)` would match nothing. The same cost\n`drawIcon` names for `Trend`."
+            },
+            {
+              "kind": "field",
+              "name": "tier",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-headless-'",
+              "description": "The prefix this tier registers its elements under.\n\n**A component that renders another renders its own tier's version of it**,\nso `helix-headless-pagination-size` composes `helix-headless-select` and\n`helix-pagination-size` composes `helix-select`. One template says\n`${this.tag('select')}` and each tier answers with its own name.\n\n**The public tag may not be the composed one, in either tier.** Using it\ncosts three things: the name means two different things depending on what a\nconsumer imported, the headless tier composes an element it does not ship,\nand the composition cannot be tested there at all, because there is no\n`helix-select` on that tier to test it against.\n\n**A prefix rather than an override per composition**, which was the first\nplan and does not compile. An override re-renders the fragment from the\nsubclass, and the fragment reads members the base keeps private:\n`PaginationSize` alone would have had to widen `options`, `current` and\n`handleChange` to `protected` so a subclass could say the same thing again.\nSixteen families of that is a lot of encapsulation spent on saying one\nword differently.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "tag",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "StaticValue"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One composed tag, as a static value a template can interpolate.\n\n`unsafeStatic` is safe by construction: the name is a literal in our own\nsource and the prefix is one of two strings this class defines. Called per\nrender and not cached, which costs nothing, because `static-html` keys its\ntemplate cache on the joined string rather than on the object.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "partNamed",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "T | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One of this element's own parts, by name, or null where it is not rendered.\n\nNot `part`, which every element already has: `Element.part` is the\n`DOMTokenList` of the names the element itself carries, and a method under\nthat name is a type error on every subclass.\n\n**One guard for every lookup.** Lit's server shim has no `querySelector`\non the render root, so a lookup reached during a server render, from a\ngetter a template reads or from `willUpdate`, throws there and nowhere\nelse. Four spellings of the same guard had grown across the library, and\na fifth site with none. Null on the server, which is what the rest of the\ncode already treats a part that has not rendered as.\n\n**`~=` and not `=`.** A part drawn in a state carries a second name while\nthe state holds, `part=\"page page-current\"`, and an exact match stops\nfinding it for exactly as long as it is the one that matters.\n\n`helix component`'s `selectors` reads these calls the way it reads a\n`querySelector('[part=\"x\"]')`, so a name nothing renders is a finding\nrather than a null an optional chain swallows.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "internals",
+              "type": {
+                "text": "ElementInternals"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The element's semantics, set without touching the DOM.\n\n`ElementInternals` sets the implicit role, which an author's own `role`\nattribute still overrides, and it writes no attribute. Setting `role` on the\nhost directly would: that is an attribute the element gives itself after it\nupgrades, which a React consumer's server markup never had, and hydration\nreports it as a mismatch.\n\nAvailable during server rendering. Lit's shim implements `attachInternals`,\nso nothing here needs a guard.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleState",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "on",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Records a boolean fact about this element as a custom state.\n\n**The host belongs to whoever rendered it, and a component's own\nbookkeeping may not be kept there.** An attribute written on the first\nupdate is markup a consumer's server never sent, so a React consumer\nhydrates a DOM that has gained attributes since and reports a mismatch it\nwill not patch up. A custom state is not in the DOM at all: it carries the\nfact to a stylesheet through `:state()` and leaves the markup alone, so the\nserver's output and the client's agree by construction.\n\n`SETTLED` carries the long version of that argument; `checked`, `open`,\n`invalid` and `has-label` are recorded the same way, each of them a state a\n`default-*` attribute resolves before React reaches the node.\n\n**Deferring the definitions is not a fix and could not be.** Importing them\nfrom an effect so the upgrades fall the other side of hydration works only\nwhile hydration is one pass: anything that splits it, a streamed segment or\na suspended boundary, puts an upgrade back inside the window. Timing cannot\nbe the guarantee when the fact is kept somewhere React reconciles.\n\nFeature-tested rather than assumed, the way `hostAria` tests element\nreferences. An engine without `CustomStateSet` records nothing and keeps\nwhatever the resting rule draws, which is the safe direction to fail.\n\n**The engines the test is for are browsers**: Safari below 17.4 and Firefox\nbelow 126, where the write is a `TypeError`, so a component bypassing this\nfails to render rather than rendering without whatever the state draws.\nLit's server shim sets `states`, so the guard passes there and records a\nstate nothing reads, which is harmless.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "whenSettled",
+              "type": {
+                "text": "Promise<void>"
+              },
+              "readonly": true,
+              "description": "Resolves a frame after the first update, when transitions are switched on.\n\n**Named `whenSettled` because `settled` is taken four times over**, by\nImage, Splitter and both color controls, none of them about transitions. A\nbase class takes the name every subclass then cannot use.\n\n**The state it reports cannot be watched, which is why this exists.** A\ncustom state is deliberately not in the DOM, so there is no\n`MutationObserver` equivalent for `ElementInternals.states`. Await this\ninstead.\n\nSeparate from `updateComplete`, which resolves in the microtask checkpoint\nthe suppression is still active in. That is the distinction `readyToMove`\nin `@fusion.dev/helix-testing` is written around.\n\nIt never resolves where `requestAnimationFrame` never fires, which is a\nserver, a hidden tab, and happy-dom. Callers that must not hang there race\nit against a timeout, as the happy-dom harness's `readyToMove` does. The\nbrowser harness's awaits it alone: a browser always runs the frame, and a\ntimer beside it was a bet on how long one takes, which a busy run lost.",
+              "default": "new Promise<void>((resolve) => { this.resolveSettled = resolve })",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "resolveSettled",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "private",
+              "description": "Resolves `whenSettled`, once, from the frame that records the state.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fromServer",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the shadow root was a server's, parsed from declarative shadow DOM.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "hydrating",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this update is hydrating a server's markup, and so has to render\nexactly what the server rendered.\n\n**Lit hydrates by assuming the markup already shows the first render.** A\nvalue that differs is recorded and never written, so the page keeps the\nserver's, and a template that differs throws. The server has no children,\nso anything a component reads from its children waits for the update after\nhydration, which `finishHydration` asks for. Without a server's markup the\nfirst render reads them and there is one render.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "serverRendered",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element hydrated a server's markup rather than rendering its own.\n\nFor what happened before hydration and cannot be heard after it: an image\nthe parser fetched fires `load` or `error` before any listener exists, so a\ncomponent asks the image instead, once, when this is true.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finishHydration",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks for the update a hydration put off, so the reads it skipped happen.\n\nCalled from `firstUpdated`, the end of the hydrating update. The render it\nschedules can only follow that one, which is the exception Lit's\nchange-in-update warning names, and it happens only on a page a server\nrendered.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "childrenKnown",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this render can know the children.\n\nA server cannot: its element shim carries attributes and no tree, so\n`children` is undefined there. A render hydrating what a server sent must\nnot, because it has to be the server's render. Anywhere else it can. A\ncomponent whose render depends on its children reads them through\n`knownChildren`, and treats \"not known\" as its own answer rather than as\n\"none\": a list that renders its empty state because nobody has looked yet is\nthe one thing an empty state must never do.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "knownChildren",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "protected",
+              "description": "The children a render may read: all of them where they are known, and none otherwise.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "assignsByName",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element's slots route by name although it asked to assign them\nby hand.\n\n**A declarative shadow root is always the by-name kind.** HTML has no way to\nask for manual assignment, so a component that assigns by hand and hydrates\na server's root gets one where `slot.assign()` does nothing, and its\nchildren land wherever their `slot` attribute sends them. The way through is\nto write that attribute, which is what `route` does. Only there: on a root\nthis element made, assignment stays manual and the consumer's markup is\nnever touched, which is what a React consumer's hydration requires.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "route",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "child",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | undefined"
+                  }
+                }
+              ],
+              "description": "Sends a child to a slot by name, on a root that routes by name.\n\n`undefined` is the default slot. Written only when it differs, so routing\nthe same child again on every update writes nothing.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "stopInner",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Stops an inner control's own announcement at this element's boundary.\n\n**A composed control is one control to a consumer, and the natives had no\nequivalent of the stop the prefixed events already get.** `<helix-select>`\nrenders a `<helix-listbox>`, and both announce: the listbox dispatches\n`input` and `change` from its own host, `input` is composed by\nspecification, and a consumer listening on the select therefore heard one\nchoice twice. Measured before this existed, on the styled tier, one choice\non the inner listbox: select `input` twice and `change` three times,\ncombobox, date input, time input and color input twice each. `Command` was\nthe only one that was right, because it happened to reach for\n`stopImmediatePropagation` for a different reason.\n\nBound on the child in the parent's template, so it runs while the event is\nstill at the child and before it can cross. The guard is for the case where\na component binds this on itself: an element must never stop its own\nannouncement, which is the one it exists to make.\n\nThis is the same job the `helix-before-*` handlers do with their own\n`stopPropagation`, and it is separate rather than folded into them because\na consumer may legitimately refuse a request without the notification ever\nhappening: the two travel at different times and one can be absent.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "relayNativeEvent",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "init",
+                  "optional": true,
+                  "type": {
+                    "text": "EventInit"
+                  }
+                }
+              ],
+              "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finalizeStyles",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "CSSResultOrNative[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "styles",
+                  "optional": true,
+                  "type": {
+                    "text": "CSSResultOrNative | CSSResultOrNative[]"
+                  }
+                }
+              ],
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "events": [
+            {
+              "type": {
+                "text": "HelixMapPanEvent"
+              },
+              "description": "The reader asked the map to move. Answer it against your own map.",
+              "name": "helix-map-pan",
+              "reactProp": "onhelix-map-pan"
+            },
+            {
+              "type": {
+                "text": "HelixMapZoomEvent"
+              },
+              "description": "The reader asked the map to zoom, by a direction rather than to a level.",
+              "name": "helix-map-zoom",
+              "reactProp": "onhelix-map-zoom"
+            }
+          ],
+          "attributes": [
+            {
+              "name": "controls",
+              "type": {
+                "text": "string | undefined"
+              },
+              "description": "Which of the controls this frame draws, as a list of what to keep.\n\n**A list rather than a switch, because the overlap is not symmetric.**\nEvery map library draws zoom controls and none of them draws pan buttons:\nMapLibre's navigation control is zoom and a compass, Leaflet's is zoom,\nGoogle's is zoom. So a consumer slotting one of those has our zoom twice\nover and our pan pad not at all, and a single switch would make them choose\nbetween a duplicate and nothing.\n\n`none` draws none of them, which is the right answer where the slotted map\nalready has controls a reader can find: what this family argues for is that\n*a* findable control exists, never that it is ours. The methods stay public\neither way, so a consumer drawing their own chrome can still drive the\nframe.\n\nAbsent is all three, which is this library's rule that a resting value is an\nattribute's absence, and it is what the stylesheet asks about: the layout\nrules are written against `[controls]:not([controls~=\"zoom\"])` rather than\nthe bare negation, or a frame that named no list at all would be laid out as\nthough it had dropped everything.",
+              "fieldName": "controls"
+            },
+            {
+              "name": "controls-placement",
+              "type": {
+                "text": "'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | undefined"
+              },
+              "description": "Which corner the controls sit in.\n\n**Configurable because there is no safe default**, and this is a collision\nrather than a taste: MapLibre puts its own controls at the top end, Leaflet\nand OpenLayers at the top start, Google's zoom at the bottom end. Whichever\ncorner this took would land on somebody's, which is why every one of those\nlibraries made it a setting too.\n\nLogical corners rather than left and right, so a right-to-left page moves\nthem without a consumer writing a second rule.\n\nAbsent is the top end, which is this library's rule that a resting value is\nan attribute's absence: a default that reflected would write an attribute\nonto every host that no server sent and nobody asked for.",
+              "fieldName": "controlsPlacement"
+            },
+            {
+              "name": "fullscreen-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Fill the screen'",
+              "description": "What the control that fills the screen is called.",
+              "fieldName": "fullscreenLabel"
+            },
+            {
+              "name": "idle-delay",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "How long the reader may be still before the chrome hides, in milliseconds.\n\nZero keeps it up, which is the default: a map's controls are how a keyboard\nreader operates it, and chrome that hides itself by default would be this\ncomponent undoing its own argument. Set it for a display map nobody drives.",
+              "fieldName": "idleDelay"
+            },
+            {
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Accessible name for the map, which is the one thing a consumer must write.\n\nThere is no sensible default. \"Map\" names the widget rather than the place,\nand a reader meeting three of them on a page learns nothing from hearing the\nsame word three times.",
+              "fieldName": "label"
+            },
+            {
+              "name": "pan-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Pan {way}'",
+              "description": "What the controls are called, for a page not in English.",
+              "fieldName": "panLabel"
+            },
+            {
+              "name": "pan-step",
+              "type": {
+                "text": "number"
+              },
+              "default": "0.25",
+              "description": "How far one press moves the map, as a fraction of what is on screen.\n\nA fraction rather than a distance, because this frame does not know the\nscale of what is inside it: a quarter of the viewport is the same gesture at\nstreet level and at country level, and a consumer who wants metres can\nmultiply by their own.",
+              "fieldName": "panStep"
+            },
+            {
+              "name": "zoom-in-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Zoom in'",
+              "description": "What the zoom controls are called.",
+              "fieldName": "zoomInLabel"
+            },
+            {
+              "name": "zoom-out-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Zoom out'",
+              "description": "What the zoom control that goes the other way is called.",
+              "fieldName": "zoomOutLabel"
+            }
+          ],
+          "cssStates": [
+            {
+              "description": "While the frame fills the screen.",
+              "name": "fullscreen"
+            },
+            {
+              "description": "While the reader has been still long enough to hide the chrome.",
+              "name": "idle"
+            },
+            {
+              "description": "Set a frame after the first render. Transitions are held off until it is, so an element never animates its own arrival.",
+              "name": "settled",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "superclass": {
+            "name": "HelixElement",
+            "package": "@fusion.dev/helix-core"
+          },
+          "summary": "A frame around somebody else's map.",
+          "helix": {
+            "category": "media",
+            "since": "0.100.0",
+            "status": "stable",
+            "documentation": "https://fusion.dev/helix/components/map",
+            "aliases": [
+              "Map frame",
+              "Map container",
+              "Geo"
+            ],
+            "tier": "headless",
+            "group": "BaseMap",
+            "part": "Root",
+            "source": "helix/headless/src/map"
+          },
+          "tagName": "helix-headless-map",
+          "customElement": true,
+          "modulePath": "src/map/root/map-root.ts",
+          "definitionPath": "src/map/root/map-root.ts"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "HelixHeadlessMap",
+          "declaration": {
+            "name": "HelixHeadlessMap",
+            "module": "src/map/root/map-root.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "helix-headless-map",
+          "declaration": {
+            "name": "HelixHeadlessMap",
+            "module": "src/map/root/map-root.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/megamenu/index.ts",