@fusion.dev/helix-core 0.0.0-dev → 0.0.2

package/dist/controllers/aria-forward-controller/aria-forward-controller.d.ts

@@ -49,6 +49,8 @@ export declare class AriaForwardController implements ReactiveController {
     private observer;
     /** Which state attributes this controller wrote, so only those are removed. */
     private readonly forwarded;
+    /** The control the record above is about, so a replacement resets it. */
+    private recorded;
     constructor(host: ReactiveControllerHost & HTMLElement, options: AriaForwardOptions);
     /**
      * Resolves the host's references and hands them to the control.

package/dist/controllers/aria-forward-controller/aria-forward-controller.js

@@ -12,22 +12,19 @@ const RELATIONSHIPS = [
  * wherever it is written, so the whole of the work is putting it on the node the
  * accessibility tree actually exposes.
  *
- * **The case that asked for it was a disclosure with a slotted trigger.**
- * `Megamenu` and `SpeedDial` write `aria-expanded` onto whatever a consumer
- * slots, and where that is a `<helix-button>` the attribute landed on a host the
- * tree reports as `generic`: measured through Chrome's own tree, a button named
- * "Mega" with no expanded state at all, on a component whose comment says the
- * write exists so a screen reader is not "told the control was a plain button
- * forever". A plain `<button slot="trigger">` never had the problem, because
- * there the host *is* the focusable node.
+ * **A state written on a host reaches nobody.** `Megamenu` and `SpeedDial` write
+ * `aria-expanded` onto whatever a consumer slots, and where that is a
+ * `<helix-button>` it lands on a host the tree reports as `generic`: measured
+ * through Chrome's own tree, a button named "Mega" with no expanded state at
+ * all. A plain `<button slot="trigger">` never had the problem, because there
+ * the host *is* the focusable node.
  *
- * **Only what this controller put there is ever taken away, and getting that
- * wrong broke three components.** The first version removed any of these from
- * the control whenever the host lacked it, which reads as the obvious way to
+ * **Only what this controller put there is ever taken away.** Removing any of
+ * these from the control whenever the host lacks it reads as the obvious way to
  * keep the two in step and quietly deletes what the component renders for
  * itself: `Combobox` writes `aria-controls="listbox"` onto its own input and
- * `Select` writes `aria-expanded` onto its own trigger, and both were wiped on
- * every update by a controller carrying nothing. Their own specs caught it.
+ * `Select` writes `aria-expanded` onto its own trigger, and a controller
+ * carrying nothing would wipe both on every update.
  *
  * So the record below holds what was forwarded last time, and a host that stops
  * carrying one removes exactly that and nothing else. A control's own attribute
@@ -97,6 +94,21 @@ export class AriaForwardController {
         if (!target) {
             return;
         }
+        /* **The record belongs to the element it was written about.** `forwarded`
+           says what this controller put on the control. Kept across a replacement,
+           it claims a value the new element never had, and the clearing branches
+           below then take off what the component wrote itself: the fault the record
+           exists to prevent, one element later.
+    
+           **No component in this library replaces its control**, which is worth
+           saying because the comment here used to name one. All fifteen consumers
+           resolve to a single fixed part rendered once. `target` is a callback and
+           its contract permits a swap, so a controller in `core` is held to the
+           contract rather than to the fifteen callers it happens to have today. */
+        if (target !== this.recorded) {
+            this.forwarded.clear();
+            this.recorded = target;
+        }
         const root = this.host.getRootNode();
         for (const [attribute, property] of RELATIONSHIPS) {
             if (!(property in target)) {
@@ -109,8 +121,24 @@ export class AriaForwardController {
             const elements = ids
                 .map((id) => root.getElementById?.(id) ?? null)
                 .filter((element) => element !== null);
-            target[property] =
-                elements.length > 0 ? elements : null;
+            const reflect = target;
+            if (elements.length > 0) {
+                reflect[property] = elements;
+                this.forwarded.add(attribute);
+                continue;
+            }
+            /* Only if this controller is what put it there, which is the same rule
+               the states below keep and for a worse reason. `MixinField` writes
+               `aria-describedby` on the control for its own hint, and assigning null
+               here removes the content attribute, so forwarding nothing wiped the
+               component's own description on all eighteen form controls. Invisible to
+               every DOM spec: happy-dom implements no ARIA element reflection, so the
+               `property in target` guard above skips this whole branch and the suite
+               is green against code that clears a description in every browser. */
+            if (this.forwarded.has(attribute)) {
+                reflect[property] = null;
+                this.forwarded.delete(attribute);
+            }
         }
         for (const attribute of STATES) {
             const value = this.host.getAttribute(attribute);
@@ -138,8 +166,7 @@ export class AriaForwardController {
     }
     /* After the render that created the control, because there is nothing to
        forward to before it exists. Every update, not only the first: a component
-       that re-renders its control, which `Button` does whenever `href` changes it
-       between an anchor and a button, produces a new element with none of this. */
+       that re-renders its control produces a new element with none of this. */
     hostUpdated() {
         this.forward();
     }

package/dist/controllers/chart-pointer-controller/chart-pointer-controller.d.ts

@@ -42,12 +42,11 @@ export declare class ChartPointerController implements ReactiveController {
      * Which axis the readings are laid out along.
      *
      * **An axis and not a boolean, because two of the four charts do not use x.**
-     * This was `tracks = true`, and every reading was resolved from the pointer's
-     * x whatever the chart was doing. A horizontal bar chart runs its categories
-     * *down* the box, so moving the pointer from the first row to the last never
-     * changed the answer: measured on four rows, all four reported the third,
-     * which is the slot the middle of the box falls in. It looked like a tooltip
-     * that would not follow and was a tooltip reading the wrong axis.
+     * A horizontal bar chart runs its categories *down* the box, so resolving
+     * every reading from the pointer's x leaves a move from the first row to the
+     * last never changing the answer: measured on four rows, all four reported
+     * the third, which is the slot the middle of the box falls in. It looks like
+     * a tooltip that will not follow and is a tooltip reading the wrong axis.
      *
      * `none` is the ring. Its slices are real elements at every angle, so the
      * reading under the pointer is the one the pointer is over, and arithmetic on

package/dist/controllers/chart-pointer-controller/chart-pointer-controller.js

@@ -34,12 +34,11 @@ export class ChartPointerController {
          * Which axis the readings are laid out along.
          *
          * **An axis and not a boolean, because two of the four charts do not use x.**
-         * This was `tracks = true`, and every reading was resolved from the pointer's
-         * x whatever the chart was doing. A horizontal bar chart runs its categories
-         * *down* the box, so moving the pointer from the first row to the last never
-         * changed the answer: measured on four rows, all four reported the third,
-         * which is the slot the middle of the box falls in. It looked like a tooltip
-         * that would not follow and was a tooltip reading the wrong axis.
+         * A horizontal bar chart runs its categories *down* the box, so resolving
+         * every reading from the pointer's x leaves a move from the first row to the
+         * last never changing the answer: measured on four rows, all four reported
+         * the third, which is the slot the middle of the box falls in. It looks like
+         * a tooltip that will not follow and is a tooltip reading the wrong axis.
          *
          * `none` is the ring. Its slices are real elements at every angle, so the
          * reading under the pointer is the one the pointer is over, and arithmetic on

package/dist/controllers/command-controller/command-controller.d.ts

@@ -56,14 +56,12 @@ export interface CommandOptions {
  * for a click, for Enter, for Space, and for anything else the platform decides
  * counts as activation later.
  *
- * The alternative was a `data-` recipe of our own with a delegated listener on
- * the document, and it is worse in every direction: a global listener a
- * consumer cannot see, an id lookup we would write ourselves, activation
- * semantics we would have to guess at, and a convention that is ours to
- * document and theirs to learn.
+ * A `data-` recipe of our own would mean a delegated document listener a
+ * consumer cannot see, an id lookup and activation semantics we would write
+ * ourselves, and a convention that is ours to document and theirs to learn.
  *
- * **Only custom commands reach a custom element.** The built-in ones —
- * `show-modal`, `close`, `toggle-popover` — are defined against native elements
+ * **Only custom commands reach a custom element.** The built-in ones
+ * (`show-modal`, `close`, `toggle-popover`) are defined against native elements
  * and the browser applies them itself; pointed at a custom element they do
  * nothing. So the names here start with `--`, which is the platform's marker
  * for "the target decides what this means", and the target deciding is exactly

package/dist/controllers/command-controller/command-controller.js

@@ -53,14 +53,12 @@ export class HelixFallbackCommandEvent extends Event {
  * for a click, for Enter, for Space, and for anything else the platform decides
  * counts as activation later.
  *
- * The alternative was a `data-` recipe of our own with a delegated listener on
- * the document, and it is worse in every direction: a global listener a
- * consumer cannot see, an id lookup we would write ourselves, activation
- * semantics we would have to guess at, and a convention that is ours to
- * document and theirs to learn.
+ * A `data-` recipe of our own would mean a delegated document listener a
+ * consumer cannot see, an id lookup and activation semantics we would write
+ * ourselves, and a convention that is ours to document and theirs to learn.
  *
- * **Only custom commands reach a custom element.** The built-in ones —
- * `show-modal`, `close`, `toggle-popover` — are defined against native elements
+ * **Only custom commands reach a custom element.** The built-in ones
+ * (`show-modal`, `close`, `toggle-popover`) are defined against native elements
  * and the browser applies them itself; pointed at a custom element they do
  * nothing. So the names here start with `--`, which is the platform's marker
  * for "the target decides what this means", and the target deciding is exactly

package/dist/controllers/copy-controller/copy-controller.d.ts

@@ -21,10 +21,8 @@ export interface CopyOptions {
  * case wrong.
  *
  * **There are two routes and both are tried**, because the modern one is gated
- * in more places than it looks: an insecure origin, an unfocused document, and a
- * Permissions Policy defaulting to `self`, which a sandboxed iframe is not. The
- * component using this reported as not working, and a control that does nothing
- * is indistinguishable from a broken one. See `write` above.
+ * in more places than it looks and a control that does nothing is
+ * indistinguishable from a broken one. See `write` above.
  *
  * **Where neither route is allowed, the failure is silence.** The confirmation
  * does not appear, which is the honest report: a message about a clipboard is

package/dist/controllers/copy-controller/copy-controller.js

@@ -57,10 +57,8 @@ const write = async (text) => {
  * case wrong.
  *
  * **There are two routes and both are tried**, because the modern one is gated
- * in more places than it looks: an insecure origin, an unfocused document, and a
- * Permissions Policy defaulting to `self`, which a sandboxed iframe is not. The
- * component using this reported as not working, and a control that does nothing
- * is indistinguishable from a broken one. See `write` above.
+ * in more places than it looks and a control that does nothing is
+ * indistinguishable from a broken one. See `write` above.
  *
  * **Where neither route is allowed, the failure is silence.** The confirmation
  * does not appear, which is the honest report: a message about a clipboard is
@@ -98,11 +96,11 @@ export class CopyController {
         }
         /* **The host may have gone while the clipboard was being written.** Writing
            is asynchronous, `hostDisconnected` runs the moment the element leaves,
-           and it clears a timer that does not exist yet: everything below this line
-           used to run afterwards regardless, starting a fresh timer on a detached
-           host and calling `requestUpdate` on it a second later. Checked here
-           rather than in `reset`, because the thing to skip is the whole
-           confirmation and not only its clock. */
+           and it clears a timer that does not exist yet, so without this the
+           confirmation starts a fresh timer on a detached host and calls
+           `requestUpdate` on it a second later. Checked here rather than in
+           `reset`, because the thing to skip is the whole confirmation and not only
+           its clock. */
         if (this.host instanceof HTMLElement && !this.host.isConnected) {
             return;
         }

package/dist/controllers/disabled-cascade-controller/disabled-cascade-controller.d.ts

@@ -21,24 +21,17 @@ type DisableableHost = ReactiveControllerHost & HTMLElement & {
  * Pushes a group's `disabled` onto its members, on every update, unasked.
  *
  * **The cascade itself is `inheritDisabled`, and this is what makes it
- * automatic.** Four groups called that function by hand from inside whichever
- * method they happened to use for writing to their items: `place` in two of
- * them, `sync` in a third, `place` again in the fourth. That works, and it is
- * the wrong shape for three reasons.
+ * automatic.** Called by hand it runs only when whichever method holds the call
+ * runs, so a group whose items changed by some other path leaves them holding
+ * the last answer, and a group that forgets the call gets no cascade at all
+ * with nothing to say so: the property exists, the attribute reflects, and the
+ * members simply ignore it. That is invisible in review and shows up only when
+ * someone disables a set.
  *
- * It runs when that method runs. A group whose items changed without going
- * through it left them holding the last answer, and which paths reach it is a
- * different set in each of the four.
- *
- * It has to be remembered. A fifth group gets no cascade at all, and nothing
- * says so: the property exists, the attribute reflects, and the members simply
- * ignore it. That is the failure this exists to make impossible, because it is
- * invisible in review and only shows up when someone disables a set.
- *
- * And it adds no API. A group already has `disabled`, from `HelixFormElement`
- * or from the consumer; nothing here introduces a property or a method for
- * anyone to call. By this repo's own rule that makes it a controller and not a
- * mixin: it reacts to a lifecycle and nothing else.
+ * It adds no API. A group already has `disabled`, from `HelixFormElement` or
+ * from the consumer; nothing here introduces a property or a method for anyone
+ * to call. By this repo's own rule that makes it a controller and not a mixin:
+ * it reacts to a lifecycle and nothing else.
  *
  * So a group states its members once, at construction, and never thinks about
  * it again:

package/dist/controllers/disabled-cascade-controller/disabled-cascade-controller.js

@@ -3,24 +3,17 @@ import { inheritDisabled, } from '../../utils/inherit-disabled/inherit-disabled.
  * Pushes a group's `disabled` onto its members, on every update, unasked.
  *
  * **The cascade itself is `inheritDisabled`, and this is what makes it
- * automatic.** Four groups called that function by hand from inside whichever
- * method they happened to use for writing to their items: `place` in two of
- * them, `sync` in a third, `place` again in the fourth. That works, and it is
- * the wrong shape for three reasons.
- *
- * It runs when that method runs. A group whose items changed without going
- * through it left them holding the last answer, and which paths reach it is a
- * different set in each of the four.
- *
- * It has to be remembered. A fifth group gets no cascade at all, and nothing
- * says so: the property exists, the attribute reflects, and the members simply
- * ignore it. That is the failure this exists to make impossible, because it is
- * invisible in review and only shows up when someone disables a set.
- *
- * And it adds no API. A group already has `disabled`, from `HelixFormElement`
- * or from the consumer; nothing here introduces a property or a method for
- * anyone to call. By this repo's own rule that makes it a controller and not a
- * mixin: it reacts to a lifecycle and nothing else.
+ * automatic.** Called by hand it runs only when whichever method holds the call
+ * runs, so a group whose items changed by some other path leaves them holding
+ * the last answer, and a group that forgets the call gets no cascade at all
+ * with nothing to say so: the property exists, the attribute reflects, and the
+ * members simply ignore it. That is invisible in review and shows up only when
+ * someone disables a set.
+ *
+ * It adds no API. A group already has `disabled`, from `HelixFormElement` or
+ * from the consumer; nothing here introduces a property or a method for anyone
+ * to call. By this repo's own rule that makes it a controller and not a mixin:
+ * it reacts to a lifecycle and nothing else.
  *
  * So a group states its members once, at construction, and never thinks about
  * it again:

package/dist/controllers/dismiss-controller/dismiss-controller.d.ts

@@ -18,7 +18,7 @@ export interface DismissOptions {
  *
  * Both, because they are different intentions with the same meaning: Escape is
  * the keyboard's way out and clicking away is the pointer's, and an overlay
- * that honours only one is one half its readers cannot dismiss.
+ * that honors only one is one half its readers cannot dismiss.
  *
  * The outside press is watched on `pointerdown` rather than `click`, so a press
  * that starts outside and drags across the overlay still counts as leaving
@@ -26,11 +26,24 @@ export interface DismissOptions {
  *
  * A press inside a frame is the third case, and it needs its own signal. The
  * frame swallows the event, so the document that owns the overlay never sees a
- * `pointerdown` at all, and where the frame is cross-origin there is nothing to
- * listen to inside it either. What is observable is that the window lost focus
- * and a frame on this page gained it, which is exactly a press the document
- * cannot see. Leaving the browser altogether blurs the window too, so what took
- * focus is the part that distinguishes them.
+ * `pointerdown` at all.
+ *
+ * Where the frame is same-origin there is a document to listen to, and this
+ * listens to it: the same handler, on every reachable frame document, so a
+ * press in there arrives as a press whose path holds nothing of the overlay,
+ * which is what it is.
+ *
+ * **The focus signal alone was not enough, and a browser difference is why.**
+ * A press in a frame moves focus into it in Chromium, so the window blurs and a
+ * frame is what took focus. WebKit does neither: focus stays on the menu item
+ * the reader pressed to open the overlay, the window never blurs, and every
+ * observable thing about that tap says nothing happened. Measured on the
+ * sandbox, whose preview is a frame filling half the tool, the settings menu
+ * could not be dismissed by pressing the component it configures.
+ *
+ * Both signals are kept, because they answer different frames. The listener
+ * only reaches same-origin ones; the blur only fires where the browser moves
+ * focus. A cross-origin frame in Chromium has the second and not the first.
  */
 export declare class DismissController implements ReactiveController {
     private readonly host;
@@ -50,6 +63,31 @@ export declare class DismissController implements ReactiveController {
      */
     private readonly handleWindowBlur;
     private readonly handlePointerDown;
+    /**
+     * Every frame document on the page this one is allowed to read.
+     *
+     * Through the shadow roots as well, because a component that renders a frame
+     * renders it inside itself: the sandbox's preview is one, and
+     * `document.querySelectorAll` cannot see it.
+     *
+     * A cross-origin frame throws on `contentDocument` rather than returning
+     * null in some browsers, so the read is guarded and the frame is simply
+     * skipped. Nothing is lost by skipping it that was not already lost: there is
+     * no listener to add to a document this one may not touch.
+     */
+    private static frameDocuments;
+    /**
+     * The frame documents being listened to, held so the same ones are released.
+     *
+     * Gathered when the overlay opens rather than watched for: an overlay is open
+     * for as long as a reader is deciding something, and a frame that arrives
+     * inside that window is a page rebuilding itself under a menu, which is not a
+     * case worth a `MutationObserver` on every open surface. Held rather than
+     * re-collected on the way out, because a frame removed while the overlay was
+     * open would otherwise be missed and one navigated elsewhere would be a
+     * different document.
+     */
+    private frames;
     /** Starts listening. */
     activate(): void;
     /** Stops listening. */

package/dist/controllers/dismiss-controller/dismiss-controller.js

@@ -41,7 +41,7 @@ const listening = new Set();
  *
  * Both, because they are different intentions with the same meaning: Escape is
  * the keyboard's way out and clicking away is the pointer's, and an overlay
- * that honours only one is one half its readers cannot dismiss.
+ * that honors only one is one half its readers cannot dismiss.
  *
  * The outside press is watched on `pointerdown` rather than `click`, so a press
  * that starts outside and drags across the overlay still counts as leaving
@@ -49,11 +49,24 @@ const listening = new Set();
  *
  * A press inside a frame is the third case, and it needs its own signal. The
  * frame swallows the event, so the document that owns the overlay never sees a
- * `pointerdown` at all, and where the frame is cross-origin there is nothing to
- * listen to inside it either. What is observable is that the window lost focus
- * and a frame on this page gained it, which is exactly a press the document
- * cannot see. Leaving the browser altogether blurs the window too, so what took
- * focus is the part that distinguishes them.
+ * `pointerdown` at all.
+ *
+ * Where the frame is same-origin there is a document to listen to, and this
+ * listens to it: the same handler, on every reachable frame document, so a
+ * press in there arrives as a press whose path holds nothing of the overlay,
+ * which is what it is.
+ *
+ * **The focus signal alone was not enough, and a browser difference is why.**
+ * A press in a frame moves focus into it in Chromium, so the window blurs and a
+ * frame is what took focus. WebKit does neither: focus stays on the menu item
+ * the reader pressed to open the overlay, the window never blurs, and every
+ * observable thing about that tap says nothing happened. Measured on the
+ * sandbox, whose preview is a frame filling half the tool, the settings menu
+ * could not be dismissed by pressing the component it configures.
+ *
+ * Both signals are kept, because they answer different frames. The listener
+ * only reaches same-origin ones; the blur only fires where the browser moves
+ * focus. A cross-origin frame in Chromium has the second and not the first.
  */
 export class DismissController {
     constructor(host, { boundary, onDismiss }) {
@@ -69,10 +82,10 @@ export class DismissController {
              * same listener on `document`, so they are siblings on one node where the
              * only ordering is registration, and propagation is about ancestors.
              *
-             * Carrying the winning depth on the event does not arrange it either, which
-             * is the version this replaced. A handler that runs before any deeper one
-             * has no way to know a deeper one exists, so it dismisses and only then
-             * loses the comparison. Registration order is the order the overlays
+             * Carrying the winning depth on the event does not arrange it either. A
+             * handler that runs before any deeper one has no way to know a deeper one
+             * exists, so it dismisses and only then loses the comparison. Registration
+             * order is the order the overlays
              * *opened*, and opening the outer one first is the ordinary case: a dialog,
              * then a select inside it. Measured, that closed both.
              *
@@ -132,11 +145,58 @@ export class DismissController {
                 this.onDismiss();
             }
         };
+        /**
+         * The frame documents being listened to, held so the same ones are released.
+         *
+         * Gathered when the overlay opens rather than watched for: an overlay is open
+         * for as long as a reader is deciding something, and a frame that arrives
+         * inside that window is a page rebuilding itself under a menu, which is not a
+         * case worth a `MutationObserver` on every open surface. Held rather than
+         * re-collected on the way out, because a frame removed while the overlay was
+         * open would otherwise be missed and one navigated elsewhere would be a
+         * different document.
+         */
+        this.frames = [];
         this.host = host;
         this.boundary = boundary;
         this.onDismiss = onDismiss;
         host.addController(this);
     }
+    /**
+     * Every frame document on the page this one is allowed to read.
+     *
+     * Through the shadow roots as well, because a component that renders a frame
+     * renders it inside itself: the sandbox's preview is one, and
+     * `document.querySelectorAll` cannot see it.
+     *
+     * A cross-origin frame throws on `contentDocument` rather than returning
+     * null in some browsers, so the read is guarded and the frame is simply
+     * skipped. Nothing is lost by skipping it that was not already lost: there is
+     * no listener to add to a document this one may not touch.
+     */
+    static frameDocuments() {
+        const found = [];
+        const walk = (root) => {
+            for (const element of root.querySelectorAll('*')) {
+                if (element instanceof HTMLIFrameElement) {
+                    try {
+                        const inner = element.contentDocument;
+                        if (inner) {
+                            found.push(inner);
+                        }
+                    }
+                    catch {
+                        // Cross-origin. The blur signal is what covers those.
+                    }
+                }
+                if (element.shadowRoot) {
+                    walk(element.shadowRoot);
+                }
+            }
+        };
+        walk(document);
+        return found;
+    }
     /** Starts listening. */
     activate() {
         if (this.active) {
@@ -147,6 +207,10 @@ export class DismissController {
         document.addEventListener('keydown', this.handleKeydown);
         document.addEventListener('pointerdown', this.handlePointerDown);
         window.addEventListener('blur', this.handleWindowBlur);
+        this.frames = DismissController.frameDocuments();
+        for (const inner of this.frames) {
+            inner.addEventListener('pointerdown', this.handlePointerDown);
+        }
     }
     /** Stops listening. */
     deactivate() {
@@ -158,6 +222,9 @@ export class DismissController {
         document.removeEventListener('keydown', this.handleKeydown);
         document.removeEventListener('pointerdown', this.handlePointerDown);
         window.removeEventListener('blur', this.handleWindowBlur);
+        for (const inner of this.frames.splice(0)) {
+            inner.removeEventListener('pointerdown', this.handlePointerDown);
+        }
     }
     hostDisconnected() {
         this.deactivate();

package/dist/controllers/drilldown-controller/drilldown-controller.d.ts

@@ -28,12 +28,9 @@ export interface DrilldownOptions {
  * with. What a reader gets instead is one panel, a title saying where they are,
  * and a way back.
  *
- * **Extracted from `Menu`, which had all of this and did not say so.** The menu
- * held a `page`, derived the rows on it, read a title off the row that opened
- * it, and reset on close; the sandbox's settings dropdown has been a drill-down
- * for as long as it has existed. None of that is about menus. Taking it out is
- * what lets a settings panel, a filter stack or a navigation tree have the same
- * behavior without one of them being a menu that is pretending.
+ * **None of this is about menus.** A settings panel, a filter stack or a
+ * navigation tree gets the same behavior without being a menu that is
+ * pretending.
  *
  * **The tree is the state.** A row's page is its own children, assigned to a
  * slot, so the controller holds one reference, the row currently drilled into,

package/dist/controllers/drilldown-controller/drilldown-controller.js

@@ -7,12 +7,9 @@
  * with. What a reader gets instead is one panel, a title saying where they are,
  * and a way back.
  *
- * **Extracted from `Menu`, which had all of this and did not say so.** The menu
- * held a `page`, derived the rows on it, read a title off the row that opened
- * it, and reset on close; the sandbox's settings dropdown has been a drill-down
- * for as long as it has existed. None of that is about menus. Taking it out is
- * what lets a settings panel, a filter stack or a navigation tree have the same
- * behavior without one of them being a menu that is pretending.
+ * **None of this is about menus.** A settings panel, a filter stack or a
+ * navigation tree gets the same behavior without being a menu that is
+ * pretending.
  *
  * **The tree is the state.** A row's page is its own children, assigned to a
  * slot, so the controller holds one reference, the row currently drilled into,

package/dist/controllers/floating-controller/floating-controller.d.ts

@@ -83,9 +83,8 @@ export interface FloatingOptions {
  * **The custom properties are declared here because this is what writes them.**
  * Each carries a measurement taken against the viewport that no stylesheet can
  * take for itself, and `core` ships no CSS, so there is no reader inside this
- * package and none of them is private. `check:hooks` pairs a `@cssproperty`
- * with a rule that reads one, in both directions, and the underscore these used
- * to carry was what exempted them from it.
+ * package and none of them is private. the `hooks` rule pairs a documented
+ * hook with a rule that reads one, in both directions.
  *
  * @cssproperty --floating-anchor-inline-size - How wide the anchor is, for a panel that matches it.
  * @cssproperty --floating-arrow-x - Where the pointer meets the anchor, along the inline axis.
@@ -99,11 +98,11 @@ export declare class FloatingController implements ReactiveController {
      * Which run of placements the results coming back belong to.
      *
      * `computePosition` is async, so a measurement started before `stop()` still
-     * resolves after it and wrote its result onto a surface that had just been
-     * taken down: the inline `position` and `translate` went back on, and so did
-     * `data-placed`, which is the attribute five families gate visibility on.
-     * Opening and closing inside one task is all it takes, since the write lands
-     * a microtask later.
+     * resolves after it and would write its result onto a surface that had just
+     * been taken down: the inline `position` and `translate` back on, and with
+     * them `data-placed`, which is the attribute five families gate visibility
+     * on. Opening and closing inside one task is all it takes, since the write
+     * lands a microtask later.
      *
      * A counter rather than an `AbortController`, because there is nothing to
      * abort: the work is already done by the time the answer arrives and the only