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

package/dist/video/root/video-root.js

@@ -129,11 +129,11 @@ const SKIP_SECONDS = 10;
  * @slot controls - Added to the control bar, before fullscreen.
  * @slot poster - Shown over the video until it starts.
  *
- * @event {Event} ended - Relayed for the same reason.
+ * @event {Event} ended - Relayed, because it does not cross a shadow boundary.
  * @event {HelixNextEvent} helix-next - Fired when the reader asks for the next item.
  * @event {HelixPreviousEvent} helix-previous - Fired when they ask for the previous one.
  * @event {Event} pause - Relayed for the same reason.
- * @event {Event} play - Relayed, because it does not cross a shadow boundary.
+ * @event {Event} play - Relayed for the same reason.
  *
  * @csspart back - The region top left, for a way out of a set.
  * @csspart captions - Subtitles on and off.
@@ -155,7 +155,6 @@ const SKIP_SECONDS = 10;
  * @csspart failure - What is said when the source will not play.
  * @csspart forward - The control that goes on ten seconds.
  * @csspart fullscreen - The whole screen, and back.
- * @csspart icon - A glyph this component draws.
  * @csspart loading - What is said while the picture waits for more of itself.
  * @csspart loading-mark - The part of that which spins.
  * @csspart more - The button that opens it.
@@ -193,39 +192,14 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
     constructor() {
         super(...arguments);
         /**
-         * Where the video is, for the common case of one file.
-         */
-        this.src = '';
-        /**
-         * A still shown before it plays, which the platform draws itself.
-         */
-        this.poster = '';
-        /**
-         * Accessible name, since a video is not described by its filename.
-         */
-        this.label = '';
-        /**
-         * Whether it starts again at the end.
-         */
-        this.loop = false;
-        /**
-         * Whether it *starts* silent, which is what an autoplaying video must do.
+         * Whether it starts on its own, which a browser only allows while silent.
          *
-         * **Renamed from `muted`, because that is what it always was.** The platform
-         * splits these two: the `muted` content attribute reflects to `defaultMuted`,
-         * and the `muted` property is live state a reader's click moves without
-         * touching the attribute. This element declared one property called `muted`,
-         * bound it to the attribute, and tracked the live state privately as
-         * `silent`, so `<helix-video>.muted` answered what the author wrote rather
-         * than whether there was sound. A name matching the platform's while meaning
-         * something else is worse than a name the platform does not have, and
-         * `check:platform-fidelity` could not see it: it compares names.
-         */
-        this.defaultMuted = false;
-        /**
-         * Whether it plays where it sits rather than taking over the screen.
+         * Forwarded rather than acted on. Whether an unprompted play is permitted is
+         * the browser's policy and not this element's, and `play()` already swallows
+         * the refusal: what follows a refused autoplay is a paused player showing its
+         * start control, which is the correct thing to be looking at.
          */
-        this.playsInline = true;
+        this.autoplay = false;
         /**
          * Whether the browser draws the controls instead of this element.
          *
@@ -233,24 +207,22 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
          * either alone, so this one is not drawn at all when it is set.
          */
         this.controls = false;
-        /**
-         * How much to fetch before anything is asked for.
-         */
-        this.preload = 'metadata';
-        /**
-         * Whether it starts on its own, which a browser only allows while silent.
-         *
-         * Forwarded rather than acted on. Whether an unprompted play is permitted is
-         * the browser's policy and not this element's, and `play()` already swallows
-         * the refusal: what follows a refused autoplay is a paused player showing its
-         * start control, which is the correct thing to be looking at.
-         */
-        this.autoplay = false;
         /**
          * How the media is fetched across origins, which decides whether a track can
          * be read.
          */
         this.crossOrigin = null;
+        /**
+         * Whether it *starts* silent, which is what an autoplaying video must do.
+         *
+         * **Named for the platform's split, which is real.** The `muted` content
+         * attribute reflects to `defaultMuted`; the `muted` property is live state a
+         * reader's click moves without touching the attribute. One property called
+         * `muted` bound to the attribute answers what the author wrote rather than
+         * whether there is sound, which is a name matching the platform's while
+         * meaning something else.
+         */
+        this.defaultMuted = false;
         /**
          * Whether the browser may offer picture in picture.
          */
@@ -259,13 +231,17 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
          * Whether the browser may offer playback on a remote device.
          */
         this.disableRemotePlayback = false;
+        /**
+         * And what they are told when it will not play at all.
+         */
+        this.errorLabel = 'This video could not be played';
         /**
          * Controls beyond the ones every player has, named in the order they appear.
          *
          * A list rather than a property apiece. A bar is a row with a budget, and a
          * boolean per feature invites a consumer to switch all of them on: naming
          * them makes the row a decision, and makes the order theirs. Anything
-         * unrecognised is skipped rather than throwing, since the list is markup and
+         * unrecognized is skipped rather than throwing, since the list is markup and
          * a typo should cost a control, not a page.
          *
          * `pip` is offered only where the platform has it, checked rather than
@@ -282,6 +258,30 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
          * and not something a player can work around.
          */
         this.extraControls = '';
+        /**
+         * How long the bar waits after the pointer stops before it goes, in ms.
+         *
+         * A wait rather than leaving with the pointer, or a reader moving across the
+         * picture to reach a control watches the bar vanish under them. Zero turns
+         * the wait off and the bar goes immediately; a large number keeps it up for
+         * as long as anyone is likely to look.
+         *
+         * The wait is only ever about *idling*. A video that is paused keeps its bar
+         * regardless, because a reader who stopped it is deciding what to do next.
+         */
+        this.idleDelay = 2500;
+        /**
+         * Accessible name, since a video is not described by its filename.
+         */
+        this.label = '';
+        /**
+         * What a reader is told while the picture is waiting for more of itself.
+         */
+        this.loadingLabel = 'Loading';
+        /**
+         * Whether it starts again at the end.
+         */
+        this.loop = false;
         /**
          * Controls that go behind one button instead of onto the bar, named the same
          * way.
@@ -301,37 +301,33 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
          */
         this.overflowControls = '';
         /**
-         * The speeds offered, slowest first, as multipliers of normal.
-         */
-        this.speeds = '0.5 1 1.5 2';
-        /**
-         * How long the bar waits after the pointer stops before it goes, in ms.
-         *
-         * It used to leave the moment the pointer did, which is not how a player
-         * behaves: a reader moving across the picture to reach a control watched it
-         * vanish under them. Zero turns the wait off and the bar goes immediately;
-         * a large number keeps it up for as long as anyone is likely to look.
-         *
-         * The wait is only ever about *idling*. A video that is paused keeps its bar
-         * regardless, because a reader who stopped it is deciding what to do next.
+         * And while it would stop it.
          */
-        this.idleDelay = 2500;
+        this.pauseLabel = 'Pause';
         /**
          * What the play control is called while it would start the video.
          */
         this.playLabel = 'Play';
         /**
-         * And while it would stop it.
+         * Whether it plays where it sits rather than taking over the screen.
          */
-        this.pauseLabel = 'Pause';
+        this.playsInline = true;
         /**
-         * What a reader is told while the picture is waiting for more of itself.
+         * A still shown before it plays, which the platform draws itself.
          */
-        this.loadingLabel = 'Loading';
+        this.poster = '';
         /**
-         * And what they are told when it will not play at all.
+         * How much to fetch before anything is asked for.
          */
-        this.errorLabel = 'This video could not be played';
+        this.preload = 'metadata';
+        /**
+         * The speeds offered, slowest first, as multipliers of normal.
+         */
+        this.speeds = '0.5 1 1.5 2';
+        /**
+         * Where the video is, for the common case of one file.
+         */
+        this.src = '';
         /**
          * Whether playback has stopped to wait for data.
          *
@@ -368,12 +364,11 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
         /**
          * How many caption tracks there are, which decides which control is drawn.
          *
-         * A count and not a boolean, and that is the whole reason it changed. Tracks
-         * resolve after the element renders, so this is what schedules the update
-         * that draws the control at all; as a boolean it went false to true when the
-         * first one arrived and then never moved again, so a second track landing
-         * left the toggle in place and the language menu was unreachable on exactly
-         * the videos it exists for.
+         * A count and not a boolean. Tracks resolve after the element renders, so
+         * this is what schedules the update that draws the control at all, and a
+         * boolean goes false to true when the first track arrives and then never
+         * moves again: a second one landing leaves the toggle in place and the
+         * language menu unreachable on exactly the videos it exists for.
          */
         this.captionCount = 0;
         this.rate = 1;
@@ -471,13 +466,10 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
         this.handleTime = () => {
             this.position = this.video?.currentTime ?? 0;
         };
-        /**
-         * Relayed, because none of these cross a shadow boundary on their own.
-         *
-         * The video is inside this element's shadow root, so a consumer listening on
-         * the element they wrote hears nothing at all without this. Input relays
-         * `change` for the same reason.
-         */
+        /* Relayed, because none of these cross a shadow boundary on their own. The
+           video is inside this element's shadow root, so a consumer listening on the
+           element they wrote hears nothing at all without this. Input relays `change`
+           for the same reason. */
         /* `emptied` is in the list for a reason worth keeping. Assigning `src` runs
            the media load algorithm, which stops playback and sets `paused` without
            firing `pause`: the only events are `emptied` and `loadstart`. Listening for
@@ -742,13 +734,9 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
     /**
      * The media's own state, under the platform's own names.
      *
-     * **This element already knew every one of these and kept them private.** It
-     * tracks `currentTime` as `position`, `duration` as `knownDuration`, `volume`
-     * as `loudness`, `paused` as `playing` and `playbackRate` as `rate`, paints
-     * them, and published none of them, so a consumer asking where the video had
-     * reached had nowhere to ask: the `<video>` is inside this shadow root and
-     * `querySelector` does not cross it. 295 is that finding across the library
-     * and this is its clearest case.
+     * **Published because there is no other way in.** The `<video>` is inside
+     * this shadow root and `querySelector` does not cross it, so a consumer
+     * asking where the video has reached has nowhere else to ask.
      *
      * **Read from the element, with the mirror as the fallback.** The element is
      * the truth and the mirror is a render cache that a media event refreshes, so
@@ -911,10 +899,9 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
      * name Video never promised, carrying a seconds count or a level between zero
      * and one rather than anything about the element.
      *
-     * Found by sweeping every family that renders a native control, which is what
-     * 308 said and not what it was read as: the first two passes both took "form
-     * control" as the population and a media component with two rails in its
-     * chrome is neither a form control nor exempt from the mechanism. See 308.
+     * Every family that renders a native control needs this, not only the form
+     * controls: a media component with two rails in its chrome is neither a form
+     * control nor exempt from the mechanism.
      */
     takeScrub(event) {
         event.stopPropagation();
@@ -955,12 +942,6 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
         });
         session.setActionHandler('play', () => this.toggle());
         session.setActionHandler('pause', () => this.toggle());
-        session.setActionHandler('seekbackward', (details) => {
-            this.seek((this.video?.currentTime ?? 0) - (details.seekOffset ?? 10));
-        });
-        session.setActionHandler('seekforward', (details) => {
-            this.seek((this.video?.currentTime ?? 0) + (details.seekOffset ?? 10));
-        });
         session.setActionHandler('seekto', (details) => {
             if (details.seekTime !== undefined && details.seekTime !== null) {
                 this.seek(details.seekTime);
@@ -1130,11 +1111,11 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
      * user activation. Both are `TypeError: Permissions check failed`, which is
      * the same message for two different causes.
      *
-     * It was `void`ed, so a refusal became an unhandled rejection: the button did
-     * nothing and said nothing, and the console entry it left named neither the
-     * element nor the reason. Caught here, the state stays honest because
-     * `aria-pressed` follows `fullscreenchange` rather than this call, so a
-     * refused request leaves a button that correctly reports "not fullscreen".
+     * Caught rather than `void`ed, or a refusal becomes an unhandled rejection
+     * naming neither the element nor the reason. The state stays honest either
+     * way, because `aria-pressed` follows `fullscreenchange` rather than this
+     * call, so a refused request leaves a button that correctly reports "not
+     * fullscreen".
      */
     async toggleFullscreen() {
         try {
@@ -1193,9 +1174,8 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
      *
      * Because CSS cannot ask. `paused` is a property of a `<video>` and never an
      * attribute, so `video:not([paused])` matches every video that has ever
-     * existed: the first version of the rule that hides the bar used exactly that
-     * and hid it always, including on a paused video, which is the one state it
-     * was written to keep it in.
+     * existed and a rule written on it hides the bar always, including on the
+     * paused video it was written to keep the bar up for.
      *
      * **A `data-` attribute is right here because of when it is written.** A fact
      * that can be true on the first update mirrors to a custom state instead, or
@@ -1203,9 +1183,8 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
      * React reports a mismatch it will not patch up. Nothing plays until somebody
      * presses play, so this one is written long past hydration and there is
      * nothing for it to disagree with. `data-closed` on `Toast.Item` and
-     * `data-closed` on `Toast.Item` is the same case; `:state(open)` and
-     * `:state(checked)` are the other one, and were `data-` attributes until
-     * 27 Aug 2026.
+     * `data-scrolled` on `AppHeader` are the same case; `:state(open)` and
+     * `:state(checked)` are the other one.
      */
     updated(changed) {
         super.updated?.(changed);
@@ -1231,8 +1210,6 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
      * two lists that have to stay in step is how a control ends up offered in one
      * place and not the other.
      */
-    /* `protected` rather than `private`: the method was already the seam and a
-       tier above simply could not reach it. */
     renderExtra(one) {
         if (one === 'remote') {
             return html `<button
@@ -1246,10 +1223,8 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
       </button>`;
         }
         /* Two templates rather than one with the name bound in, for the reason
-           written under `previous` below: a part is read from the source, so
-           `part=${one}` is a part no check can prove anything about. These two were
-           left bound when that pair was split, and `check:parts` had them exactly
-           right: both were documented and neither could be found. */
+           written under `previous` below: a part is read from the source as a
+           literal, so `part=${one}` is a part no check can prove anything about. */
         if (one === 'rewind') {
             return html `<button
         part="rewind"
@@ -1281,10 +1256,9 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
       </button>`;
         }
         /* Two templates rather than one with the name bound in, because a part is
-           read from the source: `check:selectors` scans for the literal, so a part
-           written as `part=${one}` is a part no stylesheet can be proved to reach,
-           and `check:parts` cannot find it to match against the documentation
-           either. It reported both of these as matching nothing. */
+           read from the source as a literal: `part=${one}` is a part no stylesheet
+           can be proved to reach, and nothing can match it against the
+           documentation either. */
         if (one === 'previous') {
             return html `<button
         part="previous"
@@ -1309,7 +1283,7 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
             /* A real anchor, because saving a file is the browser's job and there is
                no scripted version of it worth having.
              *
-             * **`download` only where it means something.** The attribute is honoured
+             * **`download` only where it means something.** The attribute is honored
              * for a same-origin file and ignored for any other, whatever headers come
              * back, so on a video served from a CDN it does nothing and the press
              * *navigates*: measured, clicking it took the whole page to the mp4, which
@@ -1340,14 +1314,6 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
       ${drawIcon(pictureInPicture)}
     </button>`;
     }
-    /*
-     * The same control as a row in the overflow menu.
-     *
-     * The label is words rather than a mark, which is the difference between a
-     * bar and a menu: a row has the width for a name and a reader scanning one is
-     * reading rather than recognising. `download` is a linked row, which is what
-     * `Menu.Item`'s `href` is for.
-     */
     /**
      * A toggle for one track, a menu for several, and nothing for none.
      *
@@ -1361,8 +1327,6 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
      * nobody can choose between and that is the markup's fault to fix, not this
      * component's to paper over with "Track 2".
      */
-    /* `protected` rather than `private`: the method was already the seam and a
-       tier above simply could not reach it. */
     renderCaptions() {
         /* Branched on the state rather than on the getter, so the render that draws
            this is one the state scheduled. Reading the tracks for their labels is
@@ -1411,8 +1375,14 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
         </${this.tag('menu-item')}>`)}
     </${this.tag('menu')}>`;
     }
-    /* `protected` rather than `private`: the method was already the seam and a
-       tier above simply could not reach it. */
+    /*
+     * The same control as a row in the overflow menu.
+     *
+     * The label is words rather than a mark, which is the difference between a
+     * bar and a menu: a row has the width for a name and a reader scanning one is
+     * reading rather than recognizing. `download` is a linked row, which is what
+     * `Menu.Item`'s `href` is for.
+     */
     renderOverflowItem(one) {
         if (one === 'remote') {
             return html `<${this.tag('menu-item')} part="entry"
@@ -1476,8 +1446,6 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
       Picture in picture
     </${this.tag('menu-item')}>`;
     }
-    /* `protected` rather than `private`: the method was already the seam and a
-       tier above simply could not reach it. */
     renderBar() {
         const done = this.knownDuration > 0 ? this.position / this.knownDuration : 0;
         return html `<div part="controls">
@@ -1674,12 +1642,10 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
             : nothing}
       ${
         /* Whenever it is not playing, which is what the mark means: press this
-           to play. It said that only before the first play, on the reasoning
-           that a paused video keeps its bar so the small control is already
-           there. True, and it makes the mark mean two different things at two
-           moments that are the same state. Every player a reader has used shows
-           it on pause, and the one who paused to study a frame clears it by
-           pressing the thing in the way.
+           to play. Not only before the first play, which would make the mark
+           mean two different things at two moments that are the same state.
+           Every player a reader has used shows it on pause, and the one who
+           paused to study a frame clears it by pressing the thing in the way.
 
            Not drawn at all where the browser draws its own controls, since that
            bar has a play button and two would be two. */
@@ -1701,69 +1667,69 @@ let HelixHeadlessVideo = class HelixHeadlessVideo extends HelixElement {
     </div>`;
     }
 };
-__decorate([
-    property()
-], HelixHeadlessVideo.prototype, "src", void 0);
-__decorate([
-    property()
-], HelixHeadlessVideo.prototype, "poster", void 0);
-__decorate([
-    property()
-], HelixHeadlessVideo.prototype, "label", void 0);
 __decorate([
     property({ reflect: true, type: Boolean })
-], HelixHeadlessVideo.prototype, "loop", void 0);
-__decorate([
-    property({ attribute: 'muted', reflect: true, type: Boolean })
-], HelixHeadlessVideo.prototype, "defaultMuted", void 0);
-__decorate([
-    property({ attribute: 'playsinline', converter: onUnlessFalse })
-], HelixHeadlessVideo.prototype, "playsInline", void 0);
+], HelixHeadlessVideo.prototype, "autoplay", void 0);
 __decorate([
     property({ reflect: true, type: Boolean })
 ], HelixHeadlessVideo.prototype, "controls", void 0);
-__decorate([
-    property()
-], HelixHeadlessVideo.prototype, "preload", void 0);
-__decorate([
-    property({ reflect: true, type: Boolean })
-], HelixHeadlessVideo.prototype, "autoplay", void 0);
 __decorate([
     property({ attribute: 'crossorigin' })
 ], HelixHeadlessVideo.prototype, "crossOrigin", void 0);
+__decorate([
+    property({ attribute: 'muted', reflect: true, type: Boolean })
+], HelixHeadlessVideo.prototype, "defaultMuted", void 0);
 __decorate([
     property({ attribute: 'disablepictureinpicture', reflect: true, type: Boolean })
 ], HelixHeadlessVideo.prototype, "disablePictureInPicture", void 0);
 __decorate([
     property({ attribute: 'disableremoteplayback', reflect: true, type: Boolean })
 ], HelixHeadlessVideo.prototype, "disableRemotePlayback", void 0);
+__decorate([
+    property({ attribute: 'error-label' })
+], HelixHeadlessVideo.prototype, "errorLabel", void 0);
 __decorate([
     property({ attribute: 'extra-controls' })
 ], HelixHeadlessVideo.prototype, "extraControls", void 0);
 __decorate([
-    property({ attribute: 'overflow-controls' })
-], HelixHeadlessVideo.prototype, "overflowControls", void 0);
+    property({ attribute: 'idle-delay', type: Number })
+], HelixHeadlessVideo.prototype, "idleDelay", void 0);
 __decorate([
-    property({ attribute: 'start-control' })
-], HelixHeadlessVideo.prototype, "startControl", void 0);
+    property()
+], HelixHeadlessVideo.prototype, "label", void 0);
 __decorate([
-    property({ attribute: 'speeds' })
-], HelixHeadlessVideo.prototype, "speeds", void 0);
+    property({ attribute: 'loading-label' })
+], HelixHeadlessVideo.prototype, "loadingLabel", void 0);
 __decorate([
-    property({ attribute: 'idle-delay', type: Number })
-], HelixHeadlessVideo.prototype, "idleDelay", void 0);
+    property({ reflect: true, type: Boolean })
+], HelixHeadlessVideo.prototype, "loop", void 0);
 __decorate([
-    property({ attribute: 'play-label' })
-], HelixHeadlessVideo.prototype, "playLabel", void 0);
+    property({ attribute: 'overflow-controls' })
+], HelixHeadlessVideo.prototype, "overflowControls", void 0);
 __decorate([
     property({ attribute: 'pause-label' })
 ], HelixHeadlessVideo.prototype, "pauseLabel", void 0);
 __decorate([
-    property({ attribute: 'loading-label' })
-], HelixHeadlessVideo.prototype, "loadingLabel", void 0);
+    property({ attribute: 'play-label' })
+], HelixHeadlessVideo.prototype, "playLabel", void 0);
 __decorate([
-    property({ attribute: 'error-label' })
-], HelixHeadlessVideo.prototype, "errorLabel", void 0);
+    property({ attribute: 'playsinline', converter: onUnlessFalse })
+], HelixHeadlessVideo.prototype, "playsInline", void 0);
+__decorate([
+    property()
+], HelixHeadlessVideo.prototype, "poster", void 0);
+__decorate([
+    property()
+], HelixHeadlessVideo.prototype, "preload", void 0);
+__decorate([
+    property({ attribute: 'speeds' })
+], HelixHeadlessVideo.prototype, "speeds", void 0);
+__decorate([
+    property()
+], HelixHeadlessVideo.prototype, "src", void 0);
+__decorate([
+    property({ attribute: 'start-control' })
+], HelixHeadlessVideo.prototype, "startControl", void 0);
 __decorate([
     state()
 ], HelixHeadlessVideo.prototype, "buffering", void 0);

package/dist/video-playlist/item/video-playlist-item.d.ts

@@ -41,13 +41,17 @@ import { type TemplateResult } from 'lit';
  */
 export declare class HelixHeadlessVideoPlaylistItem extends HelixElement {
     /**
-     * What identifies the entry, and what `active` is compared against.
+     * Whether the player is on this entry.
+     *
+     * Written by the playlist rather than by the entry, the way an option's
+     * selection is: an entry that made itself current would be a second answer to
+     * which one is playing.
      */
-    value: string;
+    current: boolean;
     /**
-     * The file this entry plays.
+     * Whether the entry can be chosen.
      */
-    src: string;
+    disabled: boolean;
     /**
      * What covers the picture before this entry plays, and the row's thumbnail.
      *
@@ -59,24 +63,20 @@ export declare class HelixHeadlessVideoPlaylistItem extends HelixElement {
      */
     poster: string;
     /**
-     * Whether the entry can be chosen.
+     * The file this entry plays.
      */
-    disabled: boolean;
+    src: string;
     /**
-     * Whether the player is on this entry.
-     *
-     * Written by the playlist rather than by the entry, the way an option's
-     * selection is: an entry that made itself current would be a second answer to
-     * which one is playing.
+     * What identifies the entry, and what `active` is compared against.
      */
-    current: boolean;
+    value: string;
     /**
      * The entry's name, which is the words and not everything in it.
      *
-     * `textContent` was what this used, and it takes the whole subtree: a row with
-     * a duration in `meta` reported "His Girl Friday0:06", and that string went to
-     * the player and on to the lock screen. Only the nodes the consumer left
-     * unslotted are the name; anything named is a column beside it.
+     * `textContent` takes the whole subtree: a row with a duration in `meta`
+     * reads as "His Girl Friday0:06", and that string reaches the player and the
+     * lock screen. Only the nodes the consumer left unslotted are the name;
+     * anything named is a column beside it.
      *
      * Light DOM rather than `assignedNodes`, so it answers on the server too,
      * where there is no slot to ask. `Option.text` reads its own the same way.