@fusion.dev/helix-core 0.25.1 → 0.30.0

package/custom-elements.json

@@ -118,29 +118,29 @@
           "members": [
             {
               "kind": "field",
-              "name": "#host",
-              "privacy": "private",
+              "name": "host",
               "type": {
                 "text": "ChartPointerHost"
               },
+              "privacy": "private",
               "default": "host"
             },
             {
               "kind": "field",
-              "name": "#moved",
-              "privacy": "private",
+              "name": "moved",
               "type": {
                 "text": "boolean"
               },
+              "privacy": "private",
               "default": "false"
             },
             {
               "kind": "field",
-              "name": "#plot",
-              "privacy": "private",
+              "name": "plot",
               "type": {
                 "text": "HTMLElement | undefined"
-              }
+              },
+              "privacy": "private"
             },
             {
               "kind": "field",
@@ -190,14 +190,14 @@
             },
             {
               "kind": "method",
-              "name": "#box",
+              "name": "box",
               "privacy": "private",
               "return": {
                 "type": {
                   "text": "DOMRect | undefined"
                 }
               },
-              "description": "The box the readings are laid out in, which is the plot and not the host.\n\nThe host also holds the row of labels, so measuring against it would map\nthe pointer over a box taller than the drawing. That mattered the moment a\nchart started measuring down the box rather than across it, which is what\n`axis` is for: on a horizontal bar chart the labels are beside the plot\nrather than under it, and the host is wider than the drawing by exactly\ntheir column."
+              "description": "The box the readings are laid out in, which is the plot and not the host.\n\nThe host also holds the row of labels, so measuring against it would map\nthe pointer over a box taller than the drawing. That mattered the moment a\nchart started measuring down the box rather than across it, which is what\n`axis` is for: on a horizontal bar chart the labels are beside the plot\nrather than under it, and the host is wider than the drawing by exactly\ntheir column.\n\n**Held only while it is still in the tree.** Every chart renders a\ndifferent template for its empty state, so the plot a pointer crossed\nbefore the table filled is a node Lit has since replaced: held forever, it\nmeasures a detached box and the tooltip never appears. Looked up again\nwhenever the held one has left, which is once per data arrival rather than\nonce per move."
             },
             {
               "kind": "method",
@@ -219,13 +219,13 @@
             },
             {
               "kind": "field",
-              "name": "#move",
+              "name": "move",
               "privacy": "private",
               "readonly": true
             },
             {
               "kind": "field",
-              "name": "#leave",
+              "name": "leave",
               "privacy": "private",
               "readonly": true
             }
@@ -602,7 +602,17 @@
                   "text": "Document[]"
                 }
               },
-              "description": "Every frame document on the page this one is allowed to read.\n\nThrough the shadow roots as well, because a component that renders a frame\nrenders it inside itself: the sandbox's preview is one, and\n`document.querySelectorAll` cannot see it.\n\nA cross-origin frame throws on `contentDocument` rather than returning\nnull in some browsers, so the read is guarded and the frame is simply\nskipped. Nothing is lost by skipping it that was not already lost: there is\nno listener to add to a document this one may not touch."
+              "description": "Every frame document on the page this one is allowed to read.\n\nThrough the shadow roots as well, because a component that renders a frame\nrenders it inside itself: the sandbox's preview is one, and\n`document.querySelectorAll` cannot see it.\n\nA cross-origin frame throws on `contentDocument` rather than returning\nnull in some browsers, so the read is guarded and the frame is simply\nskipped. Nothing is lost by skipping it that was not already lost: there is\nno listener to add to a document this one may not touch.\n\n**And walked only where the page holds a frame at all.** The walk is every\nelement on the page, through every shadow root, and it ran on every\n`activate`, which is every tooltip hover and every menu opening. Measured\nin Chromium on 14 Sep 2026, on a page of 10,006 elements across 500 shadow\nroots, which is the shape of a docs page: 1.36ms per walk, against a\nlength read on `getElementsByTagName('iframe')` too small for\n`performance.now` to resolve over 20,000 runs. That collection is live and\nthe engine keeps its count, so asking it is a read rather than a search.\n\n**What the count cannot see is a frame inside a shadow root**, and that is\na trade made knowingly rather than an oversight. A page whose only frame\nsits in a shadow root reads as having none and skips the walk, so a\nsame-origin frame rendered by a component is not listened to there. The\none frame this library renders inside a shadow root is the sandbox's\npreview, which is sandboxed without `allow-same-origin` and so is a\ndocument this one may not read whether or not it is found: the blur\nsignal is what covers it, and the walk never could. A page with a frame in\nthe light DOM still walks, shadow roots included.\n\nHeld for the rest of the run as well, so overlays that activate together,\na dialog opening a select from its own `updated`, walk once between them.\nA microtask and no longer: what a frame gathered here is good for is the\nlifetime of one open, and the task after this one is a page that may have\ngained a frame."
+            },
+            {
+              "kind": "field",
+              "name": "found",
+              "type": {
+                "text": "Document[] | undefined"
+              },
+              "privacy": "private",
+              "static": true,
+              "description": "What the last walk found, for the rest of the run it was made in."
             },
             {
               "kind": "field",
@@ -916,6 +926,15 @@
               "default": "'bottom-start'",
               "description": "The placement in use after the last measurement."
             },
+            {
+              "kind": "field",
+              "name": "padding",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "description": "How far the arrow keeps from the floating element's ends, measured once.\n\n`autoUpdate` runs `update` on every scroll frame of every ancestor, and\n`corner` is a `getComputedStyle` and four parses, which was a style read\nper frame for a number that does not change while the surface is up. So it\nis read as placing starts, when the surface has just been shown and has a\ncomputed style to read, and forgotten as placing stops, so a surface\nrestyled between opens is measured again. `update` measures for itself\nwhere nothing started it, which is a `reposition` on a surface placed by\nits own stylesheet."
+            },
             {
               "kind": "method",
               "name": "start",
@@ -1126,6 +1145,17 @@
                 }
               }
             },
+            {
+              "kind": "method",
+              "name": "watch",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Watches whatever `observe` names now, which `place` asks for on every placement."
+            },
             {
               "kind": "method",
               "name": "hostDisconnected",
@@ -1373,6 +1403,16 @@
               "description": "Whether the surface is showing.",
               "readonly": true
             },
+            {
+              "kind": "method",
+              "name": "hostUpdated",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the surface where the host's `open` says, however it got there."
+            },
             {
               "kind": "field",
               "name": "places",
@@ -1458,31 +1498,57 @@
           "members": [
             {
               "kind": "field",
-              "name": "#host",
-              "privacy": "private",
+              "name": "host",
               "type": {
                 "text": "SourceHost"
               },
+              "privacy": "private",
               "default": "host"
             },
             {
               "kind": "field",
-              "name": "#observer",
-              "privacy": "private",
+              "name": "observer",
               "type": {
                 "text": "MutationObserver | undefined"
-              }
+              },
+              "privacy": "private"
             },
             {
               "kind": "field",
-              "name": "#deferred",
-              "privacy": "private",
+              "name": "deferred",
               "type": {
                 "text": "boolean"
               },
+              "privacy": "private",
               "default": "false",
               "description": "Whether a hydrating render was told there was nothing, and needs the render after."
             },
+            {
+              "kind": "field",
+              "name": "version",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "Which edit of the table the parses below belong to.\n\nMoved by the watcher and by `watch()`, which are the two things that can\nchange what a chart reads without the chart doing anything: an edit to the\ntable, and `for` naming another one."
+            },
+            {
+              "kind": "field",
+              "name": "heldRows",
+              "type": {
+                "text": "Parsed<Row[]> | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "heldSeries",
+              "type": {
+                "text": "Parsed<Series[]> | undefined"
+              },
+              "privacy": "private"
+            },
             {
               "kind": "field",
               "name": "element",
@@ -1494,7 +1560,7 @@
             },
             {
               "kind": "method",
-              "name": "#resolve",
+              "name": "resolve",
               "privacy": "private",
               "return": {
                 "type": {
@@ -1509,9 +1575,43 @@
               "type": {
                 "text": "Series[]"
               },
-              "description": "The series it holds, or none.",
+              "description": "The series it holds, or none.\n\n**Parsed once per edit, not once per read.** A chart's render asks for\nthese several times over, and the pointer asks for the row count on every\nmove, so parsing the whole table on each read was a table walk per\npointermove. The parse is held against the table it came from and the\nedit it saw, and let go when either moves: `element` is compared by\nidentity, so a table replaced under the same id parses again, and the\nwatcher moves the version on every mutation it delivers.\n\nWhich is a microtask after the edit, the observer being what it is. A\nread in the same run as the edit answers the parse before it, and every\nrender that follows, which is what the watcher exists to ask for, answers\nthe one after. The same array comes back until then, so a consumer may\ncompare by identity.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "rows",
+              "type": {
+                "text": "Row[]"
+              },
+              "description": "Every row it holds, text and number alike, or none. Held the way `series` is.",
               "readonly": true
             },
+            {
+              "kind": "method",
+              "name": "parsed",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Parsed<T>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "held",
+                  "type": {
+                    "text": "Parsed<T> | undefined"
+                  }
+                },
+                {
+                  "name": "read",
+                  "type": {
+                    "text": "(table: Element | null) => T"
+                  }
+                }
+              ],
+              "description": "A held parse where it still describes the table, or a fresh one."
+            },
             {
               "kind": "method",
               "name": "hostConnected",
@@ -3368,6 +3468,25 @@
               ],
               "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."
             },
+            {
+              "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`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."
+            },
             {
               "kind": "field",
               "name": "internals",
@@ -3631,6 +3750,155 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/helix-element/react-bridge.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "reactPropsOf",
+          "return": {
+            "type": {
+              "text": "Record<string, unknown> | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "node",
+              "type": {
+                "text": "EventTarget"
+              }
+            }
+          ],
+          "description": "The props React is holding for a node, if React is holding any."
+        },
+        {
+          "kind": "function",
+          "name": "auditReactProps",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "host",
+              "type": {
+                "text": "EventTarget"
+              }
+            },
+            {
+              "name": "props",
+              "type": {
+                "text": "Record<string, unknown>"
+              }
+            }
+          ],
+          "description": "Says so when a handler prop is attached to nothing.\n\n**TypeScript will not catch any of this, and that is not our tooling's\nfault.** A JSX attribute whose name is not a valid identifier is exempt from\nchecking on an intrinsic element, and every one of ours carries a hyphen. So\n`onhelix-opne` type-checks, `on:helix-open` type-checks, and a made-up\n`totally-invented` prop type-checks, all against fully generated types that\ndo reject a wrong *value* on a normal attribute. Measured with `tsc`.\n\nThat leaves runtime as the only place a typo can be caught, and React's props\nbag as the only place to look, which the binding above already reads. Once per\nelement, because a warning that repeats on every keystroke is one a consumer\nsilences.\n\n`on:helix-open` gets its own message because it is not a mistake so much as\nthe wrong dialect. It is what the Solid types offer, correctly, and React\nbinds it as an event named `:helix-open`."
+        },
+        {
+          "kind": "function",
+          "name": "reactPropFor",
+          "return": {
+            "type": {
+              "text": "string | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "event",
+              "type": {
+                "text": "Event"
+              }
+            }
+          ],
+          "description": "The prop React would be holding for this event, if it is holding one.\n\n**A relayed native event needs a different answer from one of ours, and\ngetting it wrong doubles every call.** Measured against React 19.2.8:\n\n```\nonhelix-before-change <- helix-before-change  REACHED (React binds it with addEventListener)\nonChange       <- change        REACHED    (React's delegated root listener)\nonLoad         <- load          not reached\nonError        <- error         not reached\nonEnded        <- ended         not reached\n```\n\nReact binds a hyphenated prop directly on the element, so our own events are\nreached by name and are safe to bind again: same type, same callback, same\ncapture flag is a no-op by specification. A native name is different. React\nrecognizes `onChange` and `onLoad` as its own registration names and attaches\nnothing to the element for either; it relies on a delegated listener at the\nroot, which sees an event only if it **bubbles**, and on a non-delegated list\nit sets up for `<video>`, `<audio>` and `<img>` and never for a custom\nelement.\n\nSo a bubbling relay already arrives and must not be bound again: React's\nlistener is at the root rather than on the element, so nothing deduplicates\nit and the consumer's handler runs twice. A non-bubbling relay arrives\nnowhere, and is the bug this exists to close: `<helix-avatar>` relays `load`\nand `error`, `<helix-video>` relays `ended`, `play` and `pause`, all of them\ndeclared public API and all of them otherwise silent in React.\n\nThe name is React's own casing, `onError` rather than `onerror`, because that\nis what a consumer writes and therefore what is in the props bag. Every\nnative we relay is a single word, so capitalising the first letter is the\nwhole of the rule; a two-word name like `loadeddata` would be `onLoadedData`\nand needs the list extending rather than the rule generalising."
+        },
+        {
+          "kind": "function",
+          "name": "bindReactHandler",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "host",
+              "type": {
+                "text": "EventTarget"
+              }
+            },
+            {
+              "name": "event",
+              "type": {
+                "text": "Event"
+              }
+            }
+          ]
+        },
+        {
+          "kind": "function",
+          "name": "applyReactProperties",
+          "return": {
+            "type": {
+              "text": "boolean"
+            }
+          },
+          "parameters": [
+            {
+              "name": "host",
+              "type": {
+                "text": "LitElement"
+              }
+            }
+          ],
+          "description": "Assigns the object and function properties React is holding and never applied.\n\n**The same hydration bug as the handlers above, and it needed its own fix.**\nReact skips every prop it would have to apply imperatively while hydrating,\nnot only listeners. Strings, numbers and booleans arrive anyway, because the\nserver wrote them as attributes and Lit converts them back. An object or a\nfunction arrives by no route at all, and both halves of React agree to drop\nit: the server renderer reaches its custom element branch, finds\n`typeof value === 'object'` and `continue`s, so nothing is written into the\nHTML; and the client's hydrate path only diffs and warns for a custom element,\nnever reaching `setPropOnCustomElement`. Two skips that match, so there is no\nmismatch to report and no warning anywhere.\n\n**The binding trick above does not transfer, which is why this is separate.**\nA listener only has to exist by the time somebody interacts, so binding it at\ndispatch is late enough that hydration has certainly finished and early enough\nto catch the event being sent. A property has to be right before the first\npaint. `connectedCallback` is the obvious early moment and is the wrong one,\nmeasured: an element upgrades when its definition loads, which falls either\nside of hydration depending on how the consumer imported it, and on the side\nthis is for it is too early to see anything.\n\n**Only what the class declared, and only what could not have arrived as an\nattribute.** The first is what stops an arbitrary JSX prop being written onto\nthe element; the second is what keeps this to the properties that are actually\nbroken, rather than re-applying a string that is already correct. Three\nqualify today, `rows` on the data table and `cell` and `compare` on a table\ncolumn; the remaining `attribute: false` properties are booleans and strings a\nparent writes at runtime, which no consumer passes and this never touches.\n\n**`null` is the one place this does not reproduce a client mount, and it is\ndeliberate.** `typeof null` is `'object'`, and React assigns a null prop on a\nclient mount while dropping it on the server, so it is genuinely inside the\ngap this closes. Assigning it would faithfully reproduce a crash: the server\nleft the class default standing, and replacing that default with `null` is the\none case where closing the gap makes the page worse than leaving it open.\n\nIdempotent, so the handover needs no bookkeeping. Lit compares by identity, so\nReact's next commit assigning the same value schedules no update, and one\nassigning a different value is a change whoever writes it."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "reactPropsOf",
+          "declaration": {
+            "name": "reactPropsOf",
+            "module": "src/helix-element/react-bridge.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "auditReactProps",
+          "declaration": {
+            "name": "auditReactProps",
+            "module": "src/helix-element/react-bridge.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "reactPropFor",
+          "declaration": {
+            "name": "reactPropFor",
+            "module": "src/helix-element/react-bridge.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "bindReactHandler",
+          "declaration": {
+            "name": "bindReactHandler",
+            "module": "src/helix-element/react-bridge.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "applyReactProperties",
+          "declaration": {
+            "name": "applyReactProperties",
+            "module": "src/helix-element/react-bridge.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/helix-form-element/helix-form-element.ts",
@@ -3690,6 +3958,28 @@
               ],
               "description": "The platform's notice that an ancestor fieldset changed.\n\n**The argument is the effective state, and taking it whole is what latched\nevery control in the library.** The platform calls this for the element's\nown `disabled` as well as for a fieldset, and our own arrives here at the\nworst possible moment: reflecting `disabled` to the attribute happens\ninside Lit's `update()`, the UA fires this synchronously from that write,\nand a reactive write during an update is a change-in-update Lit does not\nre-render for. So `formDisabled` ran exactly one update behind forever.\n\nMeasured on Slider, logging what `render` saw:\n\n```\nset true    disabled true   formDisabled false  isDisabled true\nset false   disabled false  formDisabled true   isDisabled true   <- stale\n(no third render)\n```\n\nThe host came out right every time, `disabled` false, `:disabled` not\nmatching, and the inner control kept the attribute, so a control disabled\nonce could never be re-enabled. It only shows when something re-enables,\nwhich is the same shape of bug `inheritDisabled` was written for.\n\nOur own half is already in `this.disabled` and `isDisabled` is an or, so\nthis records only what the fieldset adds. That also removes the write\nentirely on the own-disabled path rather than moving it.\n\nThe one case this cannot see is a control that is disabled itself *and*\ninside a disabled fieldset, whose own `disabled` is then removed: the\neffective state does not change, so the platform does not call again, and\nthe fieldset's hold is not recorded. There is no callback to learn it from\nand reading `:disabled` here would answer about the attribute we are in the\nmiddle of removing."
             },
+            {
+              "kind": "method",
+              "name": "announceInput",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Announces `input` from the host, the way the control it stands for would.\n\nComposed, as the native one is: `input` crosses shadow boundaries by\nspecification, so a consumer listening above a composition hears it."
+            },
+            {
+              "kind": "method",
+              "name": "announceChange",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Announces `change` from the host, the way the control it stands for would.\n\n**Not composed, and that is the shape of the native event rather than a\nchoice made here.** `change` stops at a shadow boundary, so a composed\ncontrol hears its inner control's and relays it under the same name from\nits own host, which is what `onChange` binds. Every control here that\ncommits a value announces it through this, whether the commit came from an\ninner control's own `change`, a step, a scrub or a completed code, so the\nevent is one shape in one place."
+            },
             {
               "kind": "field",
               "name": "name",
@@ -3773,16 +4063,39 @@
               }
             },
             {
-              "kind": "field",
-              "name": "internals",
-              "type": {
-                "text": "ElementInternals"
-              },
+              "kind": "method",
+              "name": "partNamed",
               "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",
+              "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`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"
               }
             },
@@ -4037,6 +4350,7 @@
               }
             }
           ],
+          "events": [],
           "attributes": [
             {
               "name": "disabled",
@@ -4067,8 +4381,7 @@
             "status": "experimental",
             "documentation": "https://helix.fusion.dev/core/form-element",
             "tier": "core"
-          },
-          "events": []
+          }
         }
       ],
       "exports": [
@@ -4991,6 +5304,38 @@
             "module": "./mixins/mixin-field/mixin-field.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "MixinPickerEditing",
+          "declaration": {
+            "name": "MixinPickerEditing",
+            "module": "./mixins/mixin-picker-editing/mixin-picker-editing.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MixinPickerEditingInterface",
+          "declaration": {
+            "name": "MixinPickerEditingInterface",
+            "module": "./mixins/mixin-picker-editing/mixin-picker-editing.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MixinPickerField",
+          "declaration": {
+            "name": "MixinPickerField",
+            "module": "./mixins/mixin-picker-field/mixin-picker-field.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MixinPickerFieldInterface",
+          "declaration": {
+            "name": "MixinPickerFieldInterface",
+            "module": "./mixins/mixin-picker-field/mixin-picker-field.js"
+          }
+        },
         {
           "kind": "js",
           "name": "MixinTokens",
@@ -5023,14 +5368,6 @@
             "module": "./utils/capture-pointer/capture-pointer.js"
           }
         },
-        {
-          "kind": "js",
-          "name": "closeMarkdown",
-          "declaration": {
-            "name": "closeMarkdown",
-            "module": "./utils/close-markdown/close-markdown.js"
-          }
-        },
         {
           "kind": "js",
           "name": "closestInstance",
@@ -5720,7 +6057,7 @@
               "type": {
                 "text": "Series[]"
               },
-              "description": "The columns of the table, one series each, or none if there is no table.",
+              "description": "The columns of the table, one series each, or none if there is no table.\n\nHeld by the controller between edits, so a render reading this five\ntimes parses the table once. See `SourceController.series`.",
               "readonly": true
             },
             {
@@ -5816,29 +6153,6 @@
         }
       ]
     },
-    {
-      "kind": "javascript-module",
-      "path": "src/mixins/mixin-collection/index.ts",
-      "declarations": [],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "CollectionElement",
-          "declaration": {
-            "name": "CollectionElement",
-            "module": "./mixin-collection.js"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "MixinCollection",
-          "declaration": {
-            "name": "MixinCollection",
-            "module": "./mixin-collection.js"
-          }
-        }
-      ]
-    },
     {
       "kind": "javascript-module",
       "path": "src/mixins/mixin-collection/mixin-collection.ts",
@@ -6847,7 +7161,7 @@
             {
               "kind": "method",
               "name": "announceNatively",
-              "privacy": "private",
+              "privacy": "protected",
               "return": {
                 "type": {
                   "text": "void"
@@ -6902,20 +7216,6 @@
               "description": "Restores the value when the browser brings a form back.\n\nFalling back to `defaultValue` rather than to empty, because a restore\nwith no state is a form the browser has nothing recorded for, which is\nthe same situation as a fresh one."
             }
           ],
-          "events": [
-            {
-              "name": "input",
-              "type": {
-                "text": "Event"
-              }
-            },
-            {
-              "name": "change",
-              "type": {
-                "text": "Event"
-              }
-            }
-          ],
           "attributes": [
             {
               "name": "default-value",
@@ -7510,6 +7810,459 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/mixins/mixin-picker-editing/mixin-picker-editing.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "The public surface `MixinPickerEditing` adds.\n\nDeclared separately because TypeScript cannot emit declarations for an\nanonymous class that has private members (TS4094). Casting the mixin's return\nto this interface keeps the internals private and the build working.",
+          "name": "MixinPickerEditingInterface",
+          "members": [
+            {
+              "kind": "field",
+              "name": "editing",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether the caret is in the field, which is when it holds the value."
+            },
+            {
+              "kind": "field",
+              "name": "handleBlur",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The caret has left, so the field renders again."
+            },
+            {
+              "kind": "field",
+              "name": "handleFocus",
+              "type": {
+                "text": "(event: FocusEvent) => void"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Focusing the field opens the picker, and only from outside the element."
+            },
+            {
+              "kind": "field",
+              "name": "readOnly",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the control refuses changes while still submitting its value."
+            },
+            {
+              "kind": "method",
+              "name": "requestValue",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Refuses every change while read-only. See `readOnly`."
+            }
+          ],
+          "helix": {}
+        },
+        {
+          "kind": "mixin",
+          "description": "Grafts the typing half of a picker field: it opens on arrival, holds the\nvalue while the caret is in it, and refuses while read-only.\n\n**Over `MixinPickerField` and not part of it, because Color Input takes the\none and not the other.** Date Input and Time Input show a rendering while\nnobody is in the field, `4 August 2026` and `2:30 PM`, and the value itself\nwhile somebody is, because `Intl` formats and does not parse and a document\nbeing edited must not be a rendering of something else. That split needs to\nknow when the caret is in the field, which is `editing`; and a reader who\nreaches such a field is choosing, so arriving opens the picker. A color has\nneither: `#ff0000` is what is typed and what is shown, and a reader who has\nthe hex pastes it and never opens anything. `readOnly` is the third thing\nColor Input does not have, and a mixin cannot give it one without changing\nits API.",
+          "name": "MixinPickerEditing",
+          "members": [
+            {
+              "kind": "field",
+              "name": "readOnly",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the control refuses changes while still submitting its value.\n\n**Enforced by refusing every request in one place**, which is the seam this\ncomponent already has: `requestValue` is what every path here comes through,\nand gating it once is what stops the next call site from being written\nwithout the check.\n\nNot `disabled`, which is the confusion worth naming: a disabled control\nsubmits nothing and leaves the tab order, and a read-only one submits its\nvalue and stays reachable, which is what a form showing a value somebody\nelse set needs.",
+              "attribute": "readonly",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "editing",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "default": "false",
+              "description": "Whether the caret is in the field, which is when it holds the value."
+            },
+            {
+              "kind": "method",
+              "name": "requestValue",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Refuses every change while read-only. See `readOnly`."
+            },
+            {
+              "kind": "field",
+              "name": "handleBlur",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The caret has left, so the field renders again."
+            },
+            {
+              "kind": "field",
+              "name": "handleFocus",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Focusing the field opens the picker.\n\nA reader who reaches this control is choosing, and making them find the\ntrigger afterwards is a second action for something they have already\nasked for. Typing still works with it up, because the picker follows the\nfield rather than the other way round.\n\n**Only where focus arrived from outside this element**, which is the whole\nof the difficulty: picking shuts the panel and puts the caret back in the\nfield, so an unguarded version reopens the picker the reader just\nanswered. `relatedTarget` is where focus came from, so a hand-off from the\npicker or the trigger is left alone and only a genuine arrival opens\nanything. `returning` covers the hand-off `relatedTarget` cannot see, and\n`MixinPickerField` says why.\n\nOn the input rather than on the field, too. Focus does not bubble, so a\nlistener there covers the text and not the trigger, which is what keeps\npressing the trigger from opening the panel on focus and then shutting it\nagain on the click."
+            }
+          ],
+          "attributes": [
+            {
+              "name": "readonly",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the control refuses changes while still submitting its value.\n\n**Enforced by refusing every request in one place**, which is the seam this\ncomponent already has: `requestValue` is what every path here comes through,\nand gating it once is what stops the next call site from being written\nwithout the check.\n\nNot `disabled`, which is the confusion worth naming: a disabled control\nsubmits nothing and leaves the tab order, and a read-only one submits its\nvalue and stays reachable, which is what a form showing a value somebody\nelse set needs.",
+              "fieldName": "readOnly"
+            }
+          ],
+          "parameters": [
+            {
+              "name": "Base",
+              "type": {
+                "text": "T"
+              }
+            }
+          ]
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "MixinPickerEditingInterface",
+          "declaration": {
+            "name": "MixinPickerEditingInterface",
+            "module": "src/mixins/mixin-picker-editing/mixin-picker-editing.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MixinPickerEditing",
+          "declaration": {
+            "name": "MixinPickerEditing",
+            "module": "src/mixins/mixin-picker-editing/mixin-picker-editing.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/mixins/mixin-picker-field/mixin-picker-field.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "The public surface `MixinPickerField` adds.\n\nDeclared separately because TypeScript cannot emit declarations for an\nanonymous class that has private members (TS4094). Casting the mixin's return\nto this interface keeps the internals private and the build working.",
+          "name": "MixinPickerFieldInterface",
+          "members": [
+            {
+              "kind": "field",
+              "name": "anchor",
+              "type": {
+                "text": "HTMLElement | null"
+              },
+              "privacy": "protected",
+              "description": "What the label points at and focus lands on.\n\nThe text control, unless a family says otherwise: Color Input in `swatch`\nhas no text control, and its trigger is the only thing in the field a label\ncan name.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "control",
+              "type": {
+                "text": "HTMLInputElement | null"
+              },
+              "privacy": "protected",
+              "description": "The text input, or `null` where there is no DOM to hold one.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "display",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "protected",
+              "description": "What the field shows, which is the value unless a family renders it.\n\nDate Input and Time Input show a written date or time while nobody is in\nthe field and the value itself while somebody is; Color Input shows the\nvalue either way. What `restore` puts back is whichever the family says.",
+              "readonly": true
+            },
+            {
+              "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."
+            },
+            {
+              "kind": "field",
+              "name": "handleKeydown",
+              "type": {
+                "text": "(event: KeyboardEvent) => void"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Escape shuts the panel without moving the value."
+            },
+            {
+              "kind": "field",
+              "name": "panel",
+              "type": {
+                "text": "PopoverController"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The overlay, placed against the field rather than the trigger."
+            },
+            {
+              "kind": "method",
+              "name": "restore",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the field back where the answer differs from what was typed."
+            },
+            {
+              "kind": "method",
+              "name": "returnFocus",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the caret back in the field without the field reopening the panel."
+            },
+            {
+              "kind": "field",
+              "name": "returning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element is moving the focus itself, right now."
+            },
+            {
+              "kind": "method",
+              "name": "sync",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Reports the value and the validity the host stands behind."
+            },
+            {
+              "kind": "method",
+              "name": "validate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "description": "What is wrong with the value, in the reader's words, or nothing.\n\nThe one check the platform cannot make: the control is `type=\"text\"` and\nhas no idea what a date, a time or a color is, so the family says what one\nlooks like and `sync` reports it as `badInput`. Empty means the platform's\nown verdict stands."
+            }
+          ],
+          "helix": {}
+        },
+        {
+          "kind": "mixin",
+          "description": "Grafts a floating picker onto a text field, and the protocol between them.\n\n**Three families are this shape and were three copies of it.** Date Input,\nTime Input and Color Input each render a text control, a trigger and a\n`popover=\"manual\"` surface holding a picker that already exists on its own,\nand each owed the same wiring: the panel that floats the surface against the\nfield, the Escape that shuts it and hands the caret back, the restore that\nputs the control back where a refusal left the value, and the sync that\nreports the value and a verdict the platform cannot reach. Measured on the\ndiff that made the lift, 14 Sep 2026, comments counted: 223 lines left Date\nInput and 32 came back, 185 left Time Input and 32 came back, 87 left\nColor Input and 11 came back.\n\n**What it does not own is the picker, the typing or the value's shape.**\nWhich element floats in the surface, what a keystroke means, what the field\nshows when idle and what is wrong with a value are each the family's, which\nis why `display` and `validate` are seams here and the template stays where\nit was. A family renders `field`, `control`, `trigger` and `surface`; this\nreads them.\n\n**The parts this reads are the host's, so the name is a parameter.** A\nliteral `[part=\"control\"]` here would be a lookup nothing in this file\nrenders, which is the fault `helix component`'s `selectors` exists to catch\nand would rightly report. `MixinField.reportRequired` takes its anchor the\nsame way, and for the same reason: a mixin reads a part out of whatever host\napplies it.\n\n**Opening on focus, `readOnly` and the idle rendering are not here.** They\nare `MixinPickerEditing`'s, because Color Input has none of the three: a hex\nis pasted and read at a glance, so its field neither renders nor opens on\narrival, and giving it `readOnly` would be a property its API does not have.\n\n**Three things the two typed families share stay with them.** `renderTrigger`\ndiffers only by its icon and would still be the wrong thing to lift: a part a\nmixin renders belongs to every host that applies it, which is how\n`helix component`'s `parts` reads a chain, so `trigger-icon` would be\ncredited to Color Input, whose trigger is a swatch and documents no such\npart. `renderTag` names its part after the family, `date` or `time`, and\nwrites the label on the remove control differently in each. `valueAsDate`\nand `valueAsNumber` are public, convert a different way, and carry a\ndifferent note onto each family's page, which a mixin could only carry as\none.\n\n**Four more families look like this and are not.** Select has no text to\nhand the caret to: its panel hangs off the trigger and dismissal refocuses\nthat. Combobox has the text and a different agreement with it: a press\nanywhere in the field is inside, the gap is four, Escape closes without the\n`returning` flag because nothing there opens on arrival, and the control is\nreconciled against a completion rather than restored to a value. Input and\nTextarea open nothing, and their `readOnly` is the native attribute rather\nthan a gate on `requestValue`, so a programmatic change still lands. What\nthose two share with this is `focus()` and the platform's verdict copied in\n`sync`, which is not a protocol.",
+          "name": "MixinPickerField",
+          "members": [
+            {
+              "kind": "field",
+              "name": "panel",
+              "privacy": "protected",
+              "readonly": true,
+              "default": "new PopoverController(this, { anchor: () => this.partNamed('field'), /* The surface *and* the trigger. * * A control is not always one element: the button that opens this panel is * part of it, and a press on it is not a press outside. Scoped to the * surface alone, `pointerdown` on the trigger closes the panel and the * trigger's own `toggleOpen` reopens it on the `click` that follows, so the * panel can never be closed by the button that opened it. * `DismissController` documents this failure and takes a list for it. */ boundary: (): readonly (Element | null | undefined)[] => [ this.partNamed('surface'), this.partNamed('trigger'), ], /* Wider than the four every other panel here takes. Those sit against a control the same width as themselves and read as an extension of it; this one is a picker of its own size hanging off a field, so the gap is what says the two are separate things rather than one control that grew. */ offset: () => 8, onDismiss: () => this.requestOpen(false), open: () => this.open, placement: 'bottom-start', surface: () => this.partNamed('surface'), })",
+              "description": "The overlay, placed against the field rather than the trigger.\n\nAgainst the field because that is the box a reader sees as the control: a\ncalendar hung off a small button at one end of a wide field reads as\nbelonging to the button. `Select` anchors to its trigger for the opposite\nreason, its trigger being the whole control."
+            },
+            {
+              "kind": "field",
+              "name": "anchor",
+              "type": {
+                "text": "HTMLElement | null"
+              },
+              "privacy": "protected",
+              "description": "What the label points at and focus lands on.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "control",
+              "type": {
+                "text": "HTMLInputElement | null"
+              },
+              "privacy": "protected",
+              "description": "The text input, or `null` where there is no DOM to hold one.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "display",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "protected",
+              "description": "What the field shows, which is the value unless a family renders it.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "validate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "description": "What is wrong with the value, in the reader's words, or nothing."
+            },
+            {
+              "kind": "method",
+              "name": "restore",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the field back where the answer differs from what was typed.\n\n`requestValue` is the mixin's, and it announces and decides; this is the\nother half, which `Input` needs for the same reason: the native control has\nalready changed, so wherever the answer does not follow it, it has to be\nrestored. A refusal and a consumer who owns `value` and has not given a new\none are the same thing from here."
+            },
+            {
+              "kind": "method",
+              "name": "sync",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Reports the value and the validity the host stands behind.\n\nThe family's verdict first, where it has one, because the input is\n`type=\"text\"` and knows nothing about what it holds: `min` and `max` on a\ntext input do nothing, and the typed kind is what was given up to own the\npicker. The platform's own verdict otherwise, copied rather than\nrecomputed, with the control as the anchor so a validity bubble points at\nthe text and not at the host."
+            },
+            {
+              "kind": "field",
+              "name": "handleKeydown",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Escape shuts the panel without moving the value."
+            },
+            {
+              "kind": "field",
+              "name": "returning",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "default": "false",
+              "description": "Whether this element is moving the focus itself, right now.\n\nFocus opens the panel on the families that open on arrival, so handing\nfocus back after a pick reopens the thing that was just answered.\n`relatedTarget` was the guard and it is not enough on its own: it catches\na hand-off from the trigger, and it does not catch this, because the cell\nor the option that had focus is gone by the time the caret moves and the\ndocument has fallen back to something outside this element.\n\n**Reasoned in a browser and measured in the test runtime, and worth\nsaying which is which.** In a focused document: the reader presses a day,\nthe cell has focus, the panel is hidden, the browser moves focus off the\nremoved cell to the body, and the caret is then put back here with\n`relatedTarget` pointing at the body, which is outside this element and\nreads as an arrival. Every step is ordinary browser behavior, and none of\nit can be driven from a browser pane, where `focus()` dispatches nothing\nbecause the document is not focused. happy-dom is the exception, and it\nis what the specs run under: it dispatches `focus` from `focus()`\nsynchronously and with no `relatedTarget`, measured on 20.11.2, so the\nmixin's spec asks the hand-off directly, and two of its tests fail with\nthis guard removed.\n\nA flag rather than a better guess, because this element is the one moving\nthe focus and is the only thing that can know so. Cleared synchronously,\nsince `focus()` dispatches before it returns."
+            },
+            {
+              "kind": "method",
+              "name": "returnFocus",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the caret back in the field without the field reopening the panel."
+            },
+            {
+              "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."
+            }
+          ],
+          "parameters": [
+            {
+              "name": "Base",
+              "type": {
+                "text": "T"
+              }
+            }
+          ]
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "MixinPickerFieldInterface",
+          "declaration": {
+            "name": "MixinPickerFieldInterface",
+            "module": "src/mixins/mixin-picker-field/mixin-picker-field.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "MixinPickerField",
+          "declaration": {
+            "name": "MixinPickerField",
+            "module": "src/mixins/mixin-picker-field/mixin-picker-field.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/mixins/mixin-tokens/mixin-tokens.ts",
@@ -7958,40 +8711,6 @@
         }
       ]
     },
-    {
-      "kind": "javascript-module",
-      "path": "src/utils/close-markdown/close-markdown.ts",
-      "declarations": [
-        {
-          "kind": "function",
-          "name": "closeMarkdown",
-          "return": {
-            "type": {
-              "text": "string"
-            }
-          },
-          "parameters": [
-            {
-              "name": "partial",
-              "type": {
-                "text": "string"
-              }
-            }
-          ],
-          "description": "A prefix of a markdown document, made safe to render as it arrives.\n\n**A streamed answer is a prefix, and a prefix is rarely valid markdown.** The\nmoment a model writes an opening fence, everything after it is code that has\nnot been told it is code: a renderer handed that prefix draws paragraphs,\nthen redraws the whole block when the closing fence lands three seconds\nlater. The same holds for a backtick, a `**`, and a link whose target is\nstill being typed — each renders as punctuation until its partner arrives.\n\nSo this closes what is open. It does not parse markdown and does not render\nit: it returns a string the caller's own renderer can be handed, in which\nevery construct that was opened is also closed.\n\n**What it does not do is remove anything a reader can already read.** The\nexception is a link or image whose brackets are still open, because there is\nno closing that: a target arrives character by character, and `[the docs](ht`\nhas no valid completion that is not a guess at a URL. That fragment is\nwithheld until it is whole, which is the one case where a word appears a beat\nlater than it was received.\n\n**Inside a fence nothing else applies**, which is why closing one returns\nimmediately. The characters in a code block are code: a stray backtick or a\nlone asterisk in a shell command is not an unclosed span, and treating it as\none would append punctuation into somebody's code.\n\n**Underscores are left alone.** `_` opens emphasis in markdown and also sits\ninside `snake_case`, `__init__` and a filename, and a prefix gives no way to\ntell which: closing one turns an identifier into italics for as long as the\nrest of the word takes to arrive, which is worse than the punctuation it was\nmeant to hide. `*` does not have that problem, being punctuation everywhere\nit is not emphasis.\n\nStable across a growing prefix, which is the property that matters: calling\nthis on each frame of a stream cannot make text move that has already\nsettled, because everything it adds is at the end and everything it withholds\nis a fragment that has not been shown yet."
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "closeMarkdown",
-          "declaration": {
-            "name": "closeMarkdown",
-            "module": "src/utils/close-markdown/close-markdown.ts"
-          }
-        }
-      ]
-    },
     {
       "kind": "javascript-module",
       "path": "src/utils/closest-instance/closest-instance.ts",
@@ -8165,7 +8884,7 @@
               }
             }
           ],
-          "description": "Draws an icon that was imported by name, rather than looked up by string.\n\n**`<helix-icon name=\"play\">` indexes the whole icon set at runtime.** Its\nrender is `icons[this.name]`, and no bundler can shake a dynamic index, so\nevery consumer of any component that renders one ships all of the generated\npath data: measured at 50,814 bytes raw and 15,010 gzipped for 102 icons, and\ngrowing about 147 gzipped bytes per icon added. A named import ships one path\nand is checked when the package compiles rather than by a name lookup later.\n\nThat element still earns its place as *public* API, where a consumer writes a\nname in markup and a lookup is the only thing that can work. What it should\nnot be is how this library draws its own marks.\n\n**There is no `part` option, and there cannot be.** A part name behind an\ninterpolation is a part the manifest cannot see, so the component's own\nstylesheet matches nothing and the part stops being\nAPI. `Trend` needs one and therefore writes its `<svg>` out with a literal\n`part=\"icon\"`, which is the honest cost: a helper can carry everything except\nthe thing static analysis has to read.\n\n`data-glyph` rather than a class, because the sizing lives in\n`helix/styled/src/icon/glyph.css` and a component's own `--icon-size`\ndeclarations have to keep working untouched: the variable was read by\n`helix-icon`, and now it is read by the rule that sheet carries. Without it\nevery one of those declarations would go quietly dead and every mark in six\nfamilies would change size."
+          "description": "Draws an icon that was imported by name, rather than looked up by string.\n\n**`<helix-icon name=\"play\">` indexes the whole icon set at runtime.** Its\nrender is `icons[this.name]`, and no bundler can shake a dynamic index, so\nevery consumer of any component that renders one ships all of the generated\npath data: measured at 50,814 bytes raw and 15,010 gzipped for 102 icons, and\ngrowing about 147 gzipped bytes per icon added. A named import ships one path\nand is checked when the package compiles rather than by a name lookup later.\n\nThat element still earns its place as *public* API, where a consumer writes a\nname in markup and a lookup is the only thing that can work. What it should\nnot be is how this library draws its own marks.\n\n**There is no `part` option, and there cannot be.** A part name behind an\ninterpolation is a part the manifest cannot see, so the component's own\nstylesheet matches nothing and the part stops being\nAPI. `Trend` needs one and therefore writes its `<svg>` out with a literal\n`part=\"icon\"`, which is the honest cost: a helper can carry everything except\nthe thing static analysis has to read.\n\n`data-glyph` rather than a class, because the sizing lives in\n`helix/styled/src/shared/glyph/glyph.css` and a component's own `--icon-size`\ndeclarations have to keep working untouched: the variable was read by\n`helix-icon`, and now it is read by the rule that sheet carries. Without it\nevery one of those declarations would go quietly dead and every mark in six\nfamilies would change size."
         }
       ],
       "exports": [