gesso-core 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as prepareInputSurface, $i as textContentOf, $n as nextWordEnd, $r as borderRadius, $t as createPaintState, A as accumulatedOffsetTo, Aa as UiBeforeInputEvent, Ai as raiseContrast, An as editorFor, Ar as pathValuesEqual, At as EditableLayout, B as parseFlexDirection, Ba as UiWheelEvent, Bi as boxShadowArraysEqual, Bn as caretRectFor, Br as radialGradient, Bt as textMeasureRequest, C as describeLength, Ca as writeOverrideProperty, Ci as hasThemeExtension, Cn as linkOf, Cr as statesEqual, Ct as wordRangeIn, D as formatNumber, Da as visualState, Di as withThemeExtension, Dn as CARET_WIDTH, Dr as validateSubgrid, Dt as ELLIPSIS, E as formatExplanation, Ea as hasVisualState, Ei as themeExtensionsEqual, En as CARET_BLINK_MS, Er as UI_SUBGRID_AXES, Et as spannedRunsFor, F as constraintsEqual, Fa as UiKeyboardEvent, Fi as spacingEqual, Fn as nextCaretToggle, Fr as transformsEqual, Ft as fillTextRects, G as MainAxisAlignment, Ga as UiBinding, Gi as defaultTypography, Gn as offsetAtX, Gr as isFrLength, Gt as fontStackFor, H as sizeGridTracks, Ha as wheelDeltaYOf, Hi as defaultShapes, Hn as lineIndexForOffset, Hr as auto, Ht as textRunDecorations, I as tightenConstraints, Ia as UiPinchEvent, Ii as spacingSteps, In as syncEditorValue, Ir as MAX_GRADIENT_STOPS, It as layoutTextLines, J as parseMainAxisAlignment, Ji as defaultTextStyle, Jn as EditableTextModel, Jr as minmax, Jt as DEFAULT_FONT_SIZE, K as parseAlignContent, Ki as isTypographyRole, Kn as offsetForVerticalMove, Kr as isMinMaxTrack, Kt as registerFontStack, L as MAX_MEASURES_PER_CHILD, La as UiPointerEvent, Li as defaultShadows, Ln as resolveColorValue, Lr as gradientPaint, Lt as runCanvasStyleInto, M as LayoutRecord, Ma as UiFocusEvent, Mi as densityFactors, Mn as isEditableNode, Mr as parseTransform, Mt as buildFontString, N as Constraints, Na as UiGestureEvent, Ni as defaultSpacing, Nn as isMultiline, Nr as transform, Nt as createCanvasTextStyle, O as labelNode, Oa as visualStatesEqual, Oi as contrastRatio, On as EDITOR_PROP, Or as inputsEqual, Ot as layoutParagraph, P as clampSize, Pa as UiInputEvent, Pi as scaleSpacing, Pn as isReadOnly, Pr as transformIsIdentity, Pt as drawText, Q as pointerDeviceOf, Qi as spannedTextOf, Qn as nextGraphemeEnd, Qr as UiBorderRadiuses, Qt as computeObjectFitRect, R as isLayoutProtocol, Ra as UiTextChangeEvent, Ri as shadowsEqual, Rn as isVideoSurface, Rr as gradientsEqual, Rt as runFontString, S as SCROLLBAR_LINGER_MS, Sa as writeDeclaredProperty, Si as defineThemeExtension, Sn as linkHoverOf, Sr as normalizeStates, St as selectionRectsIn, T as formatConstraints, Ta as defaultVisualState, Ti as themeExtension, Tn as setLinkHover, Tr as validateStates, Tt as ParagraphTextMeasurer, U as AlignContent, Ua as UiNodeType, Ui as isShapeName, Un as lineLimit, Ur as fr, Ut as bumpFontStack, V as placeGridItems, Va as noKeyModifiers, Vi as boxShadowsEqual, Vn as lineIndexAtY, Vr as validateGradient, Vt as textRunBackgrounds, W as CrossAxisAlignment, Wa as DirtyFlags, Wi as shapesEqual, Wn as offsetAtPoint, Wr as isAutoLength, Wt as clearFontStacks, X as UiPlatformAdapter, Xi as resolvedSpansOf, Xn as lineEndAt, Xr as repeat, Xt as DEFAULT_TEXT_COLOR, Y as CanvasPlatformSurface, Yi as flattenTextSpans, Yn as graphemeBoundaries, Yr as percent, Yt as DEFAULT_FONT_WEIGHT, Z as capturePointer, Zi as spanAtOffset, Zn as lineStartAt, Zr as resolveLength, Zt as colorToCss, _ as LABEL_PADDING_X, _a as UiNode, _i as darkTheme, _n as isNodeInert, _r as UiProperties, _t as UiInputDispatcher, a as PaintPictureCache, aa as UiBasicColors, ai as uniformBorderRadius, an as TEXT_MATCHES_PROP, ar as resolveProperty, at as isScrollContainer, b as LayoutEngine, ba as overrideSources, bi as withContrast, bn as clearLinkHover, br as isUiRole, bt as paragraphGeometry, c as EMPTY_RECORDING, ca as colorValuesEqual, ci as UiEnvironmentKeys, cn as setMatchRanges, cr as UiGraph, ct as UiFocusManager, d as tracePathData, da as parseColor, di as noInsets, dn as selectableTextNodes, dr as getPropertyNames, dt as SCROLLBAR_INSET, ea as textSpansEqual, ei as borderRadiusCorners, en as isPaintVisible, er as previousGraphemeStart, et as touchActionFor, f as ScaledImageCache, fa as rgb8, fi as observeViewportInsets, fn as selectableTextOf, fr as inheritedPropertyFlags, ft as SCROLLBAR_MIN_THUMB, g as paintsAfterChildren, ga as UiEnvironment, gi as unknownContainerSize, gn as isNodeHitTestable, gr as propertyValuesEqualByName, gt as scrollbarZoneAt, h as hasDecorationPhase, ha as findEnvironmentKey, hi as containerBands, hn as isNodeFocusable, hr as propertyIsInherited, ht as scrollbarThumbs, i as traceRoundedRect, ia as lightColors, ii as normalizeBorderRadius, in as DEFAULT_LINE_HEIGHT_FACTOR, ir as resolveNumber, it as UiWheelController, j as contentOffset, ja as UiEventType, ji as relativeLuminance, jn as editorOf, jr as UiTransforms, jt as applyCanvasTextStyle, k as withOverrideSource, ka as MOUSE_POINTER, ki as highContrastColors, kn as caretVisibleAt, kr as paintValuesEqual, kt as proportionalFontMetrics, l as PaintRecorder, la as colorsEqual, li as UiInsetRegistry, ln as TEXT_SELECTION_PROP, lr as closestPropertyName, lt as UiHitTester, m as decorationRect, ma as createEnvironmentKey, mi as bandOf, mn as setSelectionRange, mr as propertyEffects, mt as scrollbarThumb, n as createCanvasSurface, na as colorsEqualPalette, ni as borderRadiusIsZero, nn as normalizeVerticalAlign, nr as wordRangeAt, nt as UiGestureRecognizer, o as paintPictures, oa as colorToHex, oi as defineProperty, on as clearMatchRanges, or as resolvePropertyByName, ot as UiKeyboardController, p as decorationColor, pa as rgba, pi as UiContainerSizeSource, pn as selectionRangeOf, pr as inheritedPropertyNames, pt as SCROLLBAR_THICKNESS, q as parseCrossAxisAlignment, qi as typographyEqual, qn as selectionRects, qr as isPercentLength, qt as DEFAULT_FONT_FAMILY, r as Canvas2DRenderer, ra as darkColors, ri as borderRadiusValuesEqual, rn as resolvePaintState, rr as resolveBoolean, rt as UiPinchRecognizer, s as PaintTarget, sa as colorToRgba, si as propertyValuesEqual, sn as matchRangesOf, sr as resolveString, st as UiPointerController, t as CanvasSurface, ta as textStylesEqual, ti as borderRadiusEqual, tn as normalizeTextAlign, tr as previousWordStart, tt as UiTouchScroller, u as replayPaint, ua as normalizeColor, ui as insetsEqual, un as clearSelectionRange, ur as findPropertyDefinition, ut as SCROLLBAR_HOVER_ZONE, v as drawOverlayShapes, va as DirtyNodeSet, vi as lightTheme, vn as isNodeSelectable, vr as UI_ROLES, vt as hasDrawnText, w as describeOverrides, wa as UiVisualState, wi as noThemeExtensions, wn as linkRunAtPointIn, wr as validateRole, wt as CharacterCountTextMeasurer, x as SCROLLBAR_FADE_MS, xa as resetOverrideWarnings, xi as withDensity, xn as hasTextLinks, xr as isUiSemanticState, xt as paragraphGeometryFrom, y as labelOrigin, ya as clearOverrideProperty, yi as themesEqual, yn as resolveCursor, yr as UI_SEMANTIC_STATES, yt as offsetAtPointIn, z as FlexDirection, za as UiWheelDeltaMode, zi as boxShadow, zn as videoFrameSize, zr as linearGradient, zt as spanOf } from "./CanvasSurface-CrG-uJ5o.js";
+import { $ as prepareInputSurface, $i as textContentOf, $n as nextWordEnd, $r as borderRadius, $t as createPaintState, A as accumulatedOffsetTo, Aa as UiBeforeInputEvent, Ai as raiseContrast, An as editorFor, Ar as pathValuesEqual, At as EditableLayout, B as parseFlexDirection, Ba as UiWheelEvent, Bi as boxShadowArraysEqual, Bn as caretRectFor, Br as radialGradient, Bt as textMeasureRequest, C as describeLength, Ca as writeOverrideProperty, Ci as hasThemeExtension, Cn as linkOf, Cr as statesEqual, Ct as wordRangeIn, D as formatNumber, Da as visualState, Di as withThemeExtension, Dn as CARET_WIDTH, Dr as validateSubgrid, Dt as ELLIPSIS, E as formatExplanation, Ea as hasVisualState, Ei as themeExtensionsEqual, En as CARET_BLINK_MS, Er as UI_SUBGRID_AXES, Et as spannedRunsFor, F as constraintsEqual, Fa as UiKeyboardEvent, Fi as spacingEqual, Fn as nextCaretToggle, Fr as transformsEqual, Ft as fillTextRects, G as MainAxisAlignment, Ga as UiBinding, Gi as defaultTypography, Gn as offsetAtX, Gr as isFrLength, Gt as fontStackFor, H as sizeGridTracks, Ha as wheelDeltaYOf, Hi as defaultShapes, Hn as lineIndexForOffset, Hr as auto, Ht as textRunDecorations, I as tightenConstraints, Ia as UiPinchEvent, Ii as spacingSteps, In as syncEditorValue, Ir as MAX_GRADIENT_STOPS, It as layoutTextLines, J as parseMainAxisAlignment, Ji as defaultTextStyle, Jn as EditableTextModel, Jr as minmax, Jt as DEFAULT_FONT_SIZE, K as parseAlignContent, Ki as isTypographyRole, Kn as offsetForVerticalMove, Kr as isMinMaxTrack, Kt as registerFontStack, L as MAX_MEASURES_PER_CHILD, La as UiPointerEvent, Li as defaultShadows, Ln as resolveColorValue, Lr as gradientPaint, Lt as runCanvasStyleInto, M as LayoutRecord, Ma as UiFocusEvent, Mi as densityFactors, Mn as isEditableNode, Mr as parseTransform, Mt as buildFontString, N as Constraints, Na as UiGestureEvent, Ni as defaultSpacing, Nn as isMultiline, Nr as transform, Nt as createCanvasTextStyle, O as labelNode, Oa as visualStatesEqual, Oi as contrastRatio, On as EDITOR_PROP, Or as inputsEqual, Ot as layoutParagraph, P as clampSize, Pa as UiInputEvent, Pi as scaleSpacing, Pn as isReadOnly, Pr as transformIsIdentity, Pt as drawText, Q as pointerDeviceOf, Qi as spannedTextOf, Qn as nextGraphemeEnd, Qr as UiBorderRadiuses, Qt as computeObjectFitRect, R as isLayoutProtocol, Ra as UiTextChangeEvent, Ri as shadowsEqual, Rn as isVideoSurface, Rr as gradientsEqual, Rt as runFontString, S as SCROLLBAR_LINGER_MS, Sa as writeDeclaredProperty, Si as defineThemeExtension, Sn as linkHoverOf, Sr as normalizeStates, St as selectionRectsIn, T as formatConstraints, Ta as defaultVisualState, Ti as themeExtension, Tn as setLinkHover, Tr as validateStates, Tt as ParagraphTextMeasurer, U as AlignContent, Ua as UiNodeType, Ui as isShapeName, Un as lineLimit, Ur as fr, Ut as bumpFontStack, V as placeGridItems, Va as noKeyModifiers, Vi as boxShadowsEqual, Vn as lineIndexAtY, Vr as validateGradient, Vt as textRunBackgrounds, W as CrossAxisAlignment, Wa as DirtyFlags, Wi as shapesEqual, Wn as offsetAtPoint, Wr as isAutoLength, Wt as clearFontStacks, X as UiPlatformAdapter, Xi as resolvedSpansOf, Xn as lineEndAt, Xr as repeat, Xt as DEFAULT_TEXT_COLOR, Y as CanvasPlatformSurface, Yi as flattenTextSpans, Yn as graphemeBoundaries, Yr as percent, Yt as DEFAULT_FONT_WEIGHT, Z as capturePointer, Zi as spanAtOffset, Zn as lineStartAt, Zr as resolveLength, Zt as colorToCss, _ as LABEL_PADDING_X, _a as UiNode, _i as darkTheme, _n as isNodeInert, _r as UiProperties, _t as UiInputDispatcher, a as PaintPictureCache, aa as UiBasicColors, ai as uniformBorderRadius, an as TEXT_MATCHES_PROP, ar as resolveProperty, at as isScrollContainer, b as LayoutEngine, ba as overrideSources, bi as withContrast, bn as clearLinkHover, br as isUiRole, bt as paragraphGeometry, c as EMPTY_RECORDING, ca as colorValuesEqual, ci as UiEnvironmentKeys, cn as setMatchRanges, cr as UiGraph, ct as UiFocusManager, d as tracePathData, da as parseColor, di as noInsets, dn as selectableTextNodes, dr as getPropertyNames, dt as SCROLLBAR_INSET, ea as textSpansEqual, ei as borderRadiusCorners, en as isPaintVisible, er as previousGraphemeStart, et as touchActionFor, f as ScaledImageCache, fa as rgb8, fi as observeViewportInsets, fn as selectableTextOf, fr as inheritedPropertyFlags, ft as SCROLLBAR_MIN_THUMB, g as paintsAfterChildren, ga as UiEnvironment, gi as unknownContainerSize, gn as isNodeHitTestable, gr as propertyValuesEqualByName, gt as scrollbarZoneAt, h as hasDecorationPhase, ha as findEnvironmentKey, hi as containerBands, hn as isNodeFocusable, hr as propertyIsInherited, ht as scrollbarThumbs, i as traceRoundedRect, ia as lightColors, ii as normalizeBorderRadius, in as DEFAULT_LINE_HEIGHT_FACTOR, ir as resolveNumber, it as UiWheelController, j as contentOffset, ja as UiEventType, ji as relativeLuminance, jn as editorOf, jr as UiTransforms, jt as applyCanvasTextStyle, k as withOverrideSource, ka as MOUSE_POINTER, ki as highContrastColors, kn as caretVisibleAt, kr as paintValuesEqual, kt as proportionalFontMetrics, l as PaintRecorder, la as colorsEqual, li as UiInsetRegistry, ln as TEXT_SELECTION_PROP, lr as closestPropertyName, lt as UiHitTester, m as decorationRect, ma as createEnvironmentKey, mi as bandOf, mn as setSelectionRange, mr as propertyEffects, mt as scrollbarThumb, n as createCanvasSurface, na as colorsEqualPalette, ni as borderRadiusIsZero, nn as normalizeVerticalAlign, nr as wordRangeAt, nt as UiGestureRecognizer, o as paintPictures, oa as colorToHex, oi as defineProperty, on as clearMatchRanges, or as resolvePropertyByName, ot as UiKeyboardController, p as decorationColor, pa as rgba, pi as UiContainerSizeSource, pn as selectionRangeOf, pr as inheritedPropertyNames, pt as SCROLLBAR_THICKNESS, q as parseCrossAxisAlignment, qi as typographyEqual, qn as selectionRects, qr as isPercentLength, qt as DEFAULT_FONT_FAMILY, r as Canvas2DRenderer, ra as darkColors, ri as borderRadiusValuesEqual, rn as resolvePaintState, rr as resolveBoolean, rt as UiPinchRecognizer, s as PaintTarget, sa as colorToRgba, si as propertyValuesEqual, sn as matchRangesOf, sr as resolveString, st as UiPointerController, t as CanvasSurface, ta as textStylesEqual, ti as borderRadiusEqual, tn as normalizeTextAlign, tr as previousWordStart, tt as UiTouchScroller, u as replayPaint, ua as normalizeColor, ui as insetsEqual, un as clearSelectionRange, ur as findPropertyDefinition, ut as SCROLLBAR_HOVER_ZONE, v as drawOverlayShapes, va as DirtyNodeSet, vi as lightTheme, vn as isNodeSelectable, vr as UI_ROLES, vt as hasDrawnText, w as describeOverrides, wa as UiVisualState, wi as noThemeExtensions, wn as linkRunAtPointIn, wr as validateRole, wt as CharacterCountTextMeasurer, x as SCROLLBAR_FADE_MS, xa as resetOverrideWarnings, xi as withDensity, xn as hasTextLinks, xr as isUiSemanticState, xt as paragraphGeometryFrom, y as labelOrigin, ya as clearOverrideProperty, yi as themesEqual, yn as resolveCursor, yr as UI_SEMANTIC_STATES, yt as offsetAtPointIn, z as FlexDirection, za as UiWheelDeltaMode, zi as boxShadow, zn as videoFrameSize, zr as linearGradient, zt as spanOf } from "./CanvasSurface-5dU-U3qQ.js";
 import { BehaviorSubject, EMPTY, Subject, combineLatest, distinctUntilChanged, isObservable as isObservable$1, map, of } from "rxjs";
 //#region src/animation/UiEasing.ts
 /** Progress equals time. What a spinner and a sweep want. */
@@ -175,7 +175,29 @@ var UiAnimation = class {
 	startedAt = 0;
 	begun = false;
 	subject = new Subject();
-	lastSampledAt = null;
+	/**
+	* When this animation next *wants* a sample, on the ideal timeline.
+	*
+	* The ideal one, and that word is carrying the whole fix. This used
+	* to be derived at the point of asking, as `lastSampledAt + stepMs`,
+	* which sounds equivalent and is not: frames arrive on the display's
+	* refreshes, so a sample is nearly always served a little after it
+	* was due, and measuring the next step from when it was *served*
+	* rounds the period up to a whole refresh and keeps the rounding.
+	*
+	* The arithmetic is unforgiving. A 24fps clip wants 41.67ms; on a
+	* 60Hz display the refresh at 33.3ms is too early and the one at
+	* 50ms serves it, so the next step is measured from 50, wants 91.67,
+	* and is served at 100. The period is not 41.67ms but 50ms, which is
+	* 20fps: one frame in six dropped, for ever, on the commonest clip
+	* rate there is. Measured, not reasoned about; see the spec beside
+	* this file.
+	*
+	* Advancing the ideal time by exactly `stepMs` instead lets the
+	* served times alternate between 33.3 and 50 and average out to the
+	* rate that was asked for.
+	*/
+	nextDueAt = null;
 	lastWritten;
 	finished = false;
 	constructor(cell, stepMs, reducedMotionPolicy, delayMs = 0) {
@@ -217,7 +239,7 @@ var UiAnimation = class {
 	}
 	dueAt(now) {
 		if (this.begun && now - this.startedAt < this.delayMs) return this.startedAt + this.delayMs;
-		return this.lastSampledAt === null ? now : this.lastSampledAt + this.stepMs;
+		return this.nextDueAt ?? now;
 	}
 	/**
 	* Begins at `now`, on the first frame that advances it.
@@ -243,12 +265,9 @@ var UiAnimation = class {
 		if (this.finished) return;
 		this.begin(now);
 		const elapsed = now - this.startedAt;
-		if (elapsed < this.delayMs) {
-			this.lastSampledAt = now;
-			return;
-		}
+		if (elapsed < this.delayMs) return;
 		const { value, done } = this.sample(now, elapsed - this.delayMs);
-		this.lastSampledAt = now;
+		this.scheduleNext(now);
 		if (this.lastWritten === void 0 || !this.valuesEqual(this.lastWritten, value)) {
 			this.lastWritten = value;
 			this.cell.value = value;
@@ -256,6 +275,25 @@ var UiAnimation = class {
 		}
 		if (done) this.finish();
 	}
+	/**
+	* Moves the ideal timeline on by one step.
+	*
+	* Resynchronised rather than caught up when a whole step has already
+	* gone by: that means the application stalled, or the tab was
+	* hidden, and the samples that were missed are not worth taking now.
+	* For a video they are frames already past, and presenting is a pure
+	* function of a position, so chasing the backlog would sample
+	* several times in a row to arrive exactly where a single sample
+	* arrives anyway.
+	*/
+	scheduleNext(now) {
+		if (this.stepMs <= 0) {
+			this.nextDueAt = now;
+			return;
+		}
+		const next = (this.nextDueAt ?? now) + this.stepMs;
+		this.nextDueAt = next > now ? next : now + this.stepMs;
+	}
 	/** Writes the target and completes, for reduced motion and for `duration: 0`. */
 	snap() {
 		if (this.finished) return;
@@ -1704,6 +1742,9 @@ var Host = class {
 	flowBox() {
 		return this.services.layout?.flowBox(this.node) ?? null;
 	}
+	viewportBox() {
+		return this.services.layout?.viewport?.() ?? null;
+	}
 	onLayout(listener) {
 		const layout = this.services.layout;
 		if (layout === void 0) {
@@ -6892,6 +6933,27 @@ function warnGeometryNeedsPositioning(name, position, reason) {
 //#endregion
 //#region src/modifiers/video.ts
 /**
+* The slowest and fastest a clip may be asked to run.
+*
+* Not a decoder limit — a decoder will run as fast as it is fed — but
+* a *sanity* one. Zero would be a pause spelled as a rate and would
+* divide by itself below; a negative rate is a request to run the
+* decoder backwards, which is not a thing it does; and past about four
+* the frame queue cannot stay ahead and the clip judders instead of
+* speeding up. Clamped rather than rejected, because a rate is the
+* kind of thing an application binds to a slider.
+*/
+const MIN_RATE = .0625;
+const MAX_RATE = 4;
+/**
+* How close to the end counts as having reached it.
+*
+* A tween's last sample lands on its target exactly, but a clip whose
+* tween was cancelled a frame early — by a pause, by a seek — must not
+* be mistaken for one that finished and be looped back to the start.
+*/
+const END_TOLERANCE_MS = 1;
+/**
 * Plays a video onto the node's `video` property.
 *
 * A modifier rather than a subscription in a component body for the
@@ -6903,20 +6965,29 @@ function warnGeometryNeedsPositioning(name, position, reason) {
 *
 * **Time comes from the animation driver, not from a timer.** The
 * playback is a pure function of a position, and the position is
-* driven by a repeating linear tween over the video's duration — an
-* ordinary animation on an ordinary cell. So a video is scheduled by
-* the same `ticks` phase as everything else, keeps its own frames
-* coming through the same `nextTickAt`, drops frames rather than
-* falling behind under load, and stops dead when the runtime does.
-* Nothing new had to be added to the runtime to play a video.
-*
-* **It keeps moving under reduced motion**, and that is deliberate.
-* The rule this framework applies (`UiReducedMotionPolicy`) is to stop
-* only when standing still would not state something false, and a
-* video that has frozen on its first frame is a video that has
-* finished loading badly. The media tier makes the same call for the
-* `Spinner`. An app that wants a still under reduced motion passes
-* `autoplay: false` and decides for itself.
+* driven by a linear tween over the video's duration — an ordinary
+* animation on an ordinary cell. So a video is scheduled by the same
+* `ticks` phase as everything else, keeps its own frames coming
+* through the same `nextTickAt`, drops frames rather than falling
+* behind under load, and stops dead when the runtime does. Nothing new
+* had to be added to the runtime to play a video.
+*
+* **Unless something else owns time.** A `clock` in the arguments
+* replaces the tween, and is how a clip keeps step with sound that is
+* being played somewhere this thread cannot reach. The rest of this
+* file does not care which of the two it is driven by: both end at the
+* same cell.
+*
+* **It keeps moving under reduced motion**, and that is deliberate for
+* a clip with no transport. The rule this framework applies
+* (`UiReducedMotionPolicy`) is to stop only when standing still would
+* not state something false, and a video that has frozen on its first
+* frame is a video that has finished loading badly. The media tier
+* makes the same call for the `Spinner`. A clip the reader can *drive*
+* is the other case — there the stillness is not a failure, it is a
+* clip waiting to be played — so `Video` declines to autoplay under
+* reduced motion when it has been given controls, and this modifier
+* is told so through `autoplay`.
 *
 * **Playback is shared by source, not by node.** The resolver
 * reference-counts, so two nodes pointed at one file watch one
@@ -6938,10 +7009,14 @@ function warnGeometryNeedsPositioning(name, position, reason) {
 * The video appeared to freeze, the morph juddered, and when the old
 * screen finally left, the clip carried on from the beginning.
 *
-* So the position this node presents is its own tween plus whatever
-* the playback had already reached when it resolved. Both holders then
-* agree to within a frame, no seek fires, and the continuity this
-* comment claims is actually true.
+* So a node starts its tween at whatever the playback had already
+* reached, and the cell holds an absolute position in the clip rather
+* than a distance from where this node joined. Both holders then agree
+* to within a frame, no seek fires, and the continuity this comment
+* claims is actually true. The earlier version of this kept a separate
+* offset and wrapped the sum; holding the position outright is the
+* same arithmetic with one fewer thing to get wrong, and it is what
+* makes `seek` a single assignment.
 */
 const videoSource = defineModifier({
 	name: "videoSource",
@@ -6958,16 +7033,33 @@ function load(host, args) {
 	let live = true;
 	let playback = null;
 	let stopErrors = null;
+	let stopFrames = null;
+	let stopClock = null;
 	let positionMs = 0;
-	/**
-	* Where the playback already was when this element joined it, so the
-	* tween's zero means "here" rather than "the start of the file".
-	*/
-	let offsetMs = 0;
 	/** The clip's length, known only once it has been read. */
 	let durationMs = 0;
+	let paused = args.autoplay === false;
+	let rate = clampRate(args.rate ?? 1);
+	let volume = clampVolume(args.volume ?? 1);
+	let muted = args.muted === true;
+	let state = "loading";
+	/**
+	* Whether the node is somewhere a reader could see it. Assumed true
+	* until layout says otherwise, so a clip is never held back waiting
+	* for a measurement that a headless graph will never take.
+	*/
+	let onScreen = true;
+	const changeListeners = /* @__PURE__ */ new Set();
 	args.onState?.("loading");
 	host.clear("video");
+	const announce = (next, error) => {
+		state = next;
+		args.onState?.(next, error);
+		changed();
+	};
+	const changed = () => {
+		for (const listener of changeListeners) listener();
+	};
 	const position = {
 		get value() {
 			return positionMs;
@@ -6975,39 +7067,235 @@ function load(host, args) {
 		set value(next) {
 			positionMs = next;
 			if (playback === null) return;
-			const at = durationMs > 0 ? (next + offsetMs) % durationMs : next;
-			if (playback.present(at)) host.requestFrame();
+			if (playback.present(next)) host.requestFrame();
 		}
 	};
-	args.resolver.resolve(args.source).then((resolved) => {
-		if (!live) return;
-		playback = resolved;
-		durationMs = Math.max(1, resolved.duration * 1e3);
-		offsetMs = resolved.positionMs;
-		host.set("video", resolved.surface);
-		stopErrors = resolved.onError((error) => args.onState?.("failed", error));
-		args.onState?.("playing");
-		if (args.autoplay === false) {
-			resolved.present(offsetMs);
-			host.requestFrame();
+	/**
+	* Runs the clip from where it stands to its end.
+	*
+	* A fresh tween each time rather than one repeating tween for the
+	* life of the clip, which is what this used to be. A repeating tween
+	* always starts from the value the cell held when it was built and
+	* always runs the whole duration, so there is no way to begin one
+	* part-way through — which is to say no way to seek, no way to
+	* resume after a pause, and no way to change rate without the clip
+	* jumping. Taking the loop apart into "play to the end, then decide"
+	* costs one subscription per lap and buys all three.
+	*/
+	const run = () => {
+		if (playback === null || durationMs <= 0) return;
+		const remaining = durationMs - positionMs;
+		if (remaining <= END_TOLERANCE_MS) {
+			finish();
 			return;
 		}
 		host.animate(position, durationMs, {
-			duration: durationMs,
+			duration: remaining / rate,
 			easing: linear,
-			repeat: args.loop !== false,
 			reducedMotion: "keep",
-			stepMs: resolved.frameDurationMs
-		});
+			stepMs: playback.frameDurationMs / rate
+		}).subscribe({ complete: () => {
+			if (live && !paused && durationMs - positionMs <= END_TOLERANCE_MS) finish();
+		} });
+	};
+	/** The clip reached its end: back to the start, or stop on the last frame. */
+	const finish = () => {
+		if (args.loop === false) {
+			paused = true;
+			changed();
+			return;
+		}
+		position.value = 0;
+		run();
+		changed();
+	};
+	/** Whether time should be moving, given everything that can stop it. */
+	const shouldRun = () => live && !paused && onScreen && playback !== null;
+	/**
+	* Brings the driver in line with `shouldRun`.
+	*
+	* Every one of pause, play, seek, rate and visibility ends here
+	* rather than each starting and stopping the tween itself, because
+	* the question they all really ask is the same one and the answer
+	* has to survive them happening together: a clip scrolled off screen
+	* while paused must not start playing when it comes back into view.
+	*/
+	const sync = () => {
+		host.stopAnimation(position);
+		if (shouldRun()) run();
+	};
+	const transport = {
+		get duration() {
+			return durationMs / 1e3;
+		},
+		get position() {
+			return positionMs / 1e3;
+		},
+		get paused() {
+			return paused;
+		},
+		get rate() {
+			return rate;
+		},
+		get volume() {
+			return volume;
+		},
+		get muted() {
+			return muted;
+		},
+		get seeking() {
+			return playback?.seeking ?? false;
+		},
+		get state() {
+			return state;
+		},
+		play() {
+			if (!paused) return;
+			paused = false;
+			if (durationMs > 0 && durationMs - positionMs <= END_TOLERANCE_MS) position.value = 0;
+			sync();
+			changed();
+		},
+		pause() {
+			if (paused) return;
+			paused = true;
+			sync();
+			changed();
+		},
+		seek(seconds) {
+			const wanted = Math.min(Math.max(0, seconds * 1e3), durationMs);
+			position.value = wanted;
+			sync();
+			changed();
+		},
+		setRate(next) {
+			const clamped = clampRate(next);
+			if (clamped === rate) return;
+			rate = clamped;
+			sync();
+			changed();
+		},
+		setVolume(next) {
+			const clamped = clampVolume(next);
+			const unmuted = clamped > 0 ? false : muted;
+			if (clamped === volume && unmuted === muted) return;
+			volume = clamped;
+			muted = unmuted;
+			args.onVolume?.(volume, muted);
+			changed();
+		},
+		setMuted(next) {
+			if (next === muted) return;
+			muted = next;
+			args.onVolume?.(volume, muted);
+			changed();
+		},
+		retry() {
+			if (!live) return;
+			live = false;
+			host.stopAnimation(position);
+			stopErrors?.();
+			stopFrames?.();
+			stopClock?.();
+			args.resolver.release(args.source);
+			host.clear("video");
+			load(host, args);
+		},
+		onChange(listener) {
+			changeListeners.add(listener);
+			return () => changeListeners.delete(listener);
+		}
+	};
+	args.resolver.resolve(args.source).then((resolved) => {
+		if (!live) return;
+		playback = resolved;
+		durationMs = Math.max(1, resolved.duration * 1e3);
+		positionMs = Math.min(resolved.positionMs, durationMs);
+		host.set("video", resolved.surface);
+		stopErrors = resolved.onError((error) => announce("failed", error));
+		stopFrames = resolved.onFrame?.(() => host.requestFrame()) ?? null;
+		announce("playing");
+		resolved.present(positionMs);
+		host.requestFrame();
+		attachClock();
+		sync();
+		args.onReady?.(transport);
 	}).catch((error) => {
-		if (live) args.onState?.("failed", error);
+		if (live) announce("failed", error);
 	});
+	/**
+	* Follows an external clock, when there is one.
+	*
+	* The tween is never built in this case: `sync` still decides
+	* whether time should be moving, but what moves it is the clock's
+	* own progress, sampled once per frame through the same cell the
+	* tween would have written.
+	*/
+	function attachClock() {
+		const clock = args.clock;
+		if (clock === void 0) return;
+		const followClock = () => {
+			position.value = Math.min(Math.max(0, clock.positionSeconds() * 1e3), durationMs);
+		};
+		stopClock = clock.onChange(() => {
+			paused = !clock.running;
+			followClock();
+			changed();
+		});
+		paused = !clock.running;
+		followClock();
+	}
 	host.own(() => {
 		live = false;
 		host.stopAnimation(position);
 		stopErrors?.();
+		stopFrames?.();
+		stopClock?.();
+		changeListeners.clear();
 		args.resolver.release(args.source);
 	});
+	/**
+	* Whether the node is somewhere worth decoding for.
+	*
+	* A clip scrolled out of the viewport still fetches, decodes,
+	* converts to a bitmap and uploads a texture sixty times a second
+	* for nobody, and the only thing that stops it today is the tab
+	* being hidden — which the runtime already handles, at the driver.
+	* Within a visible page nothing did, so a page of clips cost the sum
+	* of all of them however few were on screen.
+	*
+	* The test is the node's box against the root's, with no margin: a
+	* clip is either somewhere a reader could see it or it is not, and a
+	* clip that starts a frame late coming into view is a far smaller
+	* fault than one that never stops. What it must not do is *seek* —
+	* the position is left exactly where it stopped, so coming back into
+	* view resumes rather than reloads, and the decoder is not reset.
+	*/
+	function watchVisibility() {
+		if (args.pauseWhenHidden === false) return;
+		const check = () => {
+			const box = host.layoutBox();
+			const viewport = host.viewportBox();
+			if (box === null || viewport === null) return;
+			if (box.width <= 0 || box.height <= 0) return;
+			const visible = box.x < viewport.x + viewport.width && box.x + box.width > viewport.x && box.y < viewport.y + viewport.height && box.y + box.height > viewport.y;
+			if (visible === onScreen) return;
+			onScreen = visible;
+			sync();
+			changed();
+		};
+		host.onLayout(check);
+		check();
+	}
+	watchVisibility();
+}
+function clampVolume(volume) {
+	if (!Number.isFinite(volume)) return 1;
+	return Math.min(1, Math.max(0, volume));
+}
+function clampRate(rate) {
+	if (!Number.isFinite(rate)) return 1;
+	return Math.min(MAX_RATE, Math.max(MIN_RATE, rate));
 }
 //#endregion
 //#region src/modifiers/scroll.ts
@@ -11324,6 +11612,13 @@ function readFullBoxVersion(reader) {
 	reader.skip(3);
 	return version;
 }
+/** The same, for the boxes whose flags say which fields are present. */
+function readFullBox(reader) {
+	return {
+		version: reader.u8(),
+		flags: reader.u8() << 16 | reader.u8() << 8 | reader.u8()
+	};
+}
 /**
 * Reads the first video track out of an MP4.
 *
@@ -11333,25 +11628,13 @@ function readFullBoxVersion(reader) {
 * not understand this file", and those want different fixes.
 */
 function demuxMp4Video(data) {
-	const reader = new Reader(new DataView(data));
-	const limit = data.byteLength;
-	let moov = null;
-	let sawFragment = false;
-	let sawFtyp = false;
-	walkBoxes(reader, 0, limit, (box) => {
-		if (box.type === "ftyp") sawFtyp = true;
-		else if (box.type === "moov") moov = box;
-		else if (box.type === "moof" || box.type === "sidx") sawFragment = true;
-	});
+	const { reader, moov, moofs, sawFtyp } = openMp4(data);
 	if (!sawFtyp && moov === null) throw new Error("Not an MP4: no ftyp or moov box at the top level of the file.");
 	if (moov === null) throw new Error("This MP4 has no moov box, so there is no sample table to read.");
-	const table = findVideoTrack(reader, moov);
-	if (table === null) {
-		if (sawFragment) throw new Error("This is a fragmented MP4 (it has moof boxes), which this demuxer does not read. Remux it to a progressive file: `ffmpeg -i in.mp4 -c copy -movflags +faststart out.mp4`.");
-		throw new Error("This MP4 has no video track, or none this demuxer recognises.");
-	}
-	const samples = buildSamples(table);
-	if (samples.length === 0) throw new Error(sawFragment ? "This MP4 has an empty sample table and moof boxes: it is fragmented, which this demuxer does not read." : "This MP4 video track has no samples.");
+	const table = findTrack(reader, moov, "vide");
+	if (table === null) throw new Error("This MP4 has no video track, or none this demuxer recognises.");
+	const samples = samplesOf(reader, table, moov, moofs);
+	if (samples.length === 0) throw new Error(moofs.length > 0 ? "This fragmented MP4 has no samples for its video track. Its fragments may be in other files: this reads the fragments in the buffer it was given, not an index of segments to fetch." : "This MP4 video track has no samples.");
 	let durationUs = 0;
 	let frameDurationUs = Infinity;
 	for (const sample of samples) {
@@ -11368,24 +11651,99 @@ function demuxMp4Video(data) {
 		frameDurationUs: Number.isFinite(frameDurationUs) ? frameDurationUs : Math.round(1e6 / 60)
 	};
 }
-function findVideoTrack(reader, moov) {
+/** The top-level walk both entry points start from. */
+function openMp4(data) {
+	const reader = new Reader(new DataView(data));
+	const limit = data.byteLength;
+	let moov = null;
+	const moofs = [];
+	let sawFtyp = false;
+	walkBoxes(reader, 0, limit, (box) => {
+		if (box.type === "ftyp") sawFtyp = true;
+		else if (box.type === "moov") moov = box;
+		else if (box.type === "moof") moofs.push(box);
+	});
+	return {
+		reader,
+		moov,
+		moofs,
+		sawFtyp
+	};
+}
+/**
+* Moves a track's presentation times so the first picture is at zero.
+*
+* **A file's earliest presentation timestamp is not required to be
+* zero, and for anything encoded with B-frames it is not.** A `ctts`
+* shifts each sample's composition time forward of its decode time,
+* and the shift applied to the first sample is the reorder depth: two
+* frames, for the clips x264 writes by default. So a plain six second
+* clip at 24fps has its first picture at 83333us and its last ending
+* at 6.083s, and a player that believed those numbers would report a
+* duration 83ms too long and, far worse, have no picture at all to
+* show for position zero.
+*
+* That last part is not hypothetical. It is exactly what a paused
+* clip looked like before this existed: `present(0)` found nothing
+* due, because nothing *was* due, and since a paused clip never asks
+* again the still stayed blank forever. A playing one hid it by
+* advancing past 83ms within two frames.
+*
+* Subtracting a constant keeps every sample's order, duration and
+* relationship to its neighbours; all it changes is where the clock
+* starts. Which is what an edit list would usually be doing, and is
+* the part of one worth having.
+*/
+function rebaseToZero(samples) {
+	if (samples.length === 0) return samples;
+	let earliest = Infinity;
+	for (const sample of samples) earliest = Math.min(earliest, sample.timestampUs);
+	if (earliest <= 0 || !Number.isFinite(earliest)) return samples;
+	return samples.map((sample) => ({
+		...sample,
+		timestampUs: sample.timestampUs - earliest
+	}));
+}
+/**
+* A track's samples, from wherever this file keeps them.
+*
+* The two shapes are not a spectrum: a progressive file's samples are
+* in tables in the `moov` and a fragmented file's are described inline
+* in each `moof`, and a file is one or the other. `mvex` is the
+* declaration — a file that has it is fragmented even if this buffer
+* happens to hold no fragments yet — and the sample tables are the
+* fallback, so a file with neither comes back empty rather than
+* half-read.
+*/
+function samplesOf(reader, table, moov, moofs) {
+	const defaults = readTrackExtends(reader, moov);
+	return rebaseToZero(defaults.size === 0 && moofs.length === 0 ? buildSamples(table) : buildFragmentedSamples(reader, moofs, table, defaults));
+}
+function findTrack(reader, moov, kind) {
 	let found = null;
 	walkBoxes(reader, moov.start, moov.end, (trak) => {
 		if (trak.type !== "trak" || found !== null) return;
-		const table = readTrack(reader, trak);
+		const table = readTrack(reader, trak, kind);
 		if (table !== null) found = table;
 	});
 	return found;
 }
-function readTrack(reader, trak) {
+function readTrack(reader, trak, kind) {
 	let mdia = null;
+	let trackId = 0;
 	walkBoxes(reader, trak.start, trak.end, (box) => {
+		if (box.type === "tkhd") {
+			const version = readFullBoxVersion(reader);
+			reader.skip(version === 1 ? 16 : 8);
+			trackId = reader.u32();
+			return;
+		}
 		if (box.type === "mdia") mdia = box;
 	});
 	if (mdia === null) return null;
 	const media = mdia;
 	let timescale = 0;
-	let isVideo = false;
+	let matches = false;
 	let minf = null;
 	walkBoxes(reader, media.start, media.end, (box) => {
 		if (box.type === "mdhd") {
@@ -11401,20 +11759,22 @@ function readTrack(reader, trak) {
 		if (box.type === "hdlr") {
 			readFullBoxVersion(reader);
 			reader.skip(4);
-			isVideo = reader.ascii(4) === "vide";
+			matches = reader.ascii(4) === kind;
 			return;
 		}
 		if (box.type === "minf") minf = box;
 	});
-	if (!isVideo || minf === null || timescale <= 0) return null;
+	if (!matches || minf === null || timescale <= 0) return null;
 	let stbl = null;
 	walkBoxes(reader, minf.start, minf.end, (box) => {
 		if (box.type === "stbl") stbl = box;
 	});
 	if (stbl === null) return null;
-	return readSampleTable(reader, stbl, timescale);
+	const table = readSampleTable(reader, stbl, timescale, kind);
+	if (table !== null) table.trackId = trackId;
+	return table;
 }
-function readSampleTable(reader, stbl, timescale) {
+function readSampleTable(reader, stbl, timescale, kind) {
 	const table = {
 		timescale,
 		deltas: [],
@@ -11425,12 +11785,17 @@ function readSampleTable(reader, stbl, timescale) {
 		syncSamples: [],
 		codec: "",
 		codedWidth: 0,
-		codedHeight: 0
+		codedHeight: 0,
+		trackId: 0,
+		sampleRate: 0,
+		channels: 0,
+		sampleSize: 0
 	};
 	walkBoxes(reader, stbl.start, stbl.end, (box) => {
 		switch (box.type) {
 			case "stsd":
-				readSampleDescription(reader, box, table);
+				if (kind === "soun") readAudioSampleDescription(reader, box, table);
+				else readSampleDescription(reader, box, table);
 				break;
 			case "stts": {
 				readFullBoxVersion(reader);
@@ -11548,17 +11913,322 @@ function readSampleDescription(reader, stsd, table) {
 			table.codec = format;
 			return;
 		}
-		if (child.type === "av1C" || child.type === "vpcC") {
-			table.description = reader.bytes(child.end - child.start);
-			table.codec = format;
+		if (child.type === "av1C") {
+			const record = reader.bytes(child.end - child.start);
+			table.codec = av1CodecString(format, record);
+			return;
+		}
+		if (child.type === "vpcC") {
+			const record = reader.bytes(child.end - child.start);
+			table.codec = vp9CodecString(format, record);
 		}
 	});
 	if (table.codec === "") table.codec = format;
 }
+/**
+* The audio sample entry, and the codec configuration inside it.
+*
+* The fixed fields are `AudioSampleEntry`'s: six reserved bytes and a
+* data reference index, then eight bytes that were a version, a
+* revision and a vendor in QuickTime and are reserved here, the
+* channel count, the sample size, two pre-defined and two reserved,
+* and a sample rate written as 16.16 fixed point — of which only the
+* whole part is ever meaningful, because no encoder writes a
+* fractional sample rate.
+*
+* **Version 1 and 2 entries are not read past their fixed fields.**
+* A version 1 `AudioSampleEntry` carries four extra fields and a
+* version 2 carries a different layout entirely; both are rare outside
+* QuickTime, and the child boxes this actually wants are found by
+* walking from the end of whichever header was read. Getting the
+* header length wrong would make that walk start mid-box and find
+* nothing, which is why the version is read rather than assumed.
+*/
+function readAudioSampleDescription(reader, stsd, table) {
+	readFullBoxVersion(reader);
+	if (reader.u32() === 0) return;
+	const entry = readBoxHeader(reader, stsd.end);
+	if (entry === null) return;
+	reader.skip(6);
+	reader.skip(2);
+	const version = reader.u16();
+	reader.skip(6);
+	table.channels = reader.u16();
+	table.sampleSize = reader.u16();
+	reader.skip(2);
+	reader.skip(2);
+	table.sampleRate = reader.u16();
+	reader.skip(2);
+	if (version === 1) reader.skip(16);
+	else if (version === 2) reader.skip(36);
+	const format = entry.type;
+	table.codec = format;
+	walkBoxes(reader, reader.offset, entry.end, (child) => {
+		if (child.type === "esds") {
+			readElementaryStreamDescriptor(reader, child, table, format);
+			return;
+		}
+		if (child.type === "dOps" || child.type === "alac" || child.type === "dfLa") table.description = reader.bytes(child.end - child.start);
+	});
+}
+/**
+* The `esds` box, for the two numbers a codec string needs.
+*
+* An ES descriptor is a little tag-length-value tree, and this walks
+* exactly as far into it as `mp4a.40.2` requires: the
+* `DecoderConfigDescriptor` for the object type indication (`40` for
+* MPEG-4 audio), and the `DecoderSpecificInfo` inside it, whose first
+* five bits are the audio object type (`2` for AAC-LC). That inner
+* payload is also the `AudioSpecificConfig` that `AudioDecoder` wants
+* as its description, so it is kept whole.
+*
+* Lengths are written in a variable-length form where the top bit of
+* each byte says another follows — the same encoding MIDI uses for
+* delta times and MP4 inherited from MPEG-4 systems.
+*/
+function readElementaryStreamDescriptor(reader, esds, table, format) {
+	readFullBoxVersion(reader);
+	const end = esds.end;
+	const readLength = () => {
+		let length = 0;
+		for (let index = 0; index < 4; index++) {
+			const byte = reader.u8();
+			length = length << 7 | byte & 127;
+			if ((byte & 128) === 0) break;
+		}
+		return length;
+	};
+	while (reader.offset < end) {
+		const tag = reader.u8();
+		const length = readLength();
+		const payloadEnd = reader.offset + length;
+		if (payloadEnd > end) return;
+		if (tag === 3) {
+			reader.skip(2);
+			const flags = reader.u8();
+			if ((flags & 128) !== 0) reader.skip(2);
+			if ((flags & 64) !== 0) reader.skip(reader.u8());
+			if ((flags & 32) !== 0) reader.skip(2);
+			continue;
+		}
+		if (tag === 4) {
+			const objectType = reader.u8();
+			reader.skip(12);
+			table.codec = `${format}.${objectType.toString(16)}`;
+			continue;
+		}
+		if (tag === 5) {
+			const config = reader.bytes(length);
+			table.description = config;
+			const first = config[0];
+			if (first !== void 0) {
+				const audioObjectType = first >> 3;
+				if (audioObjectType !== 0 && audioObjectType !== 31) table.codec = `${table.codec}.${audioObjectType}`;
+			}
+			return;
+		}
+		reader.offset = payloadEnd;
+	}
+}
+/**
+* Reads the first audio track out of an MP4.
+*
+* Null rather than a throw for a file that simply has no audio, which
+* is the ordinary case for the clips this framework plays and is not
+* an error in any sense. A file that *has* an audio track this cannot
+* read still throws, for the reason `demuxMp4Video` gives: "no audio
+* track" and "an audio track I do not understand" want different
+* fixes.
+*/
+function demuxMp4Audio(data) {
+	const { reader, moov, moofs } = openMp4(data);
+	if (moov === null) return null;
+	const table = findTrack(reader, moov, "soun");
+	if (table === null) return null;
+	const samples = samplesOf(reader, table, moov, moofs);
+	if (samples.length === 0) throw new Error("This MP4 has an audio track with no samples this demuxer can read.");
+	let durationUs = 0;
+	for (const sample of samples) durationUs = Math.max(durationUs, sample.timestampUs + sample.durationUs);
+	return {
+		codec: table.codec,
+		sampleRate: table.sampleRate,
+		channels: table.channels,
+		sampleSize: table.sampleSize,
+		description: table.description,
+		samples,
+		durationUs
+	};
+}
+/**
+* `av01.0.04M.08`, out of the `av1C` record.
+*
+* The bare format is not a codec string for AV1 — `VideoDecoder`
+* answers `supported: false` for `av01` alone — so a file whose codec
+* was reported as just the format never played at all. Every field
+* below is in the record's first three bytes, which is the whole of
+* the fixed part of an `AV1CodecConfigurationRecord`:
+*
+*   byte 0: a marker bit and a version
+*   byte 1: seq_profile (3 bits), seq_level_idx_0 (5 bits)
+*   byte 2: seq_tier_0, high_bitdepth, twelve_bit, monochrome,
+*           chroma subsampling and sample position
+*
+* The string wants the profile, the level as two decimal digits, the
+* tier as `M` or `H`, and the bit depth as two decimal digits. Falls
+* back to the format for a record too short to read, where claiming a
+* precise string would be worse than claiming none.
+*/
+function av1CodecString(format, record) {
+	const second = record[1];
+	const third = record[2];
+	if (second === void 0 || third === void 0) return format;
+	const profile = second >> 5;
+	const level = second & 31;
+	const tier = (third & 128) !== 0 ? "H" : "M";
+	const highBitDepth = (third & 64) !== 0;
+	const depth = (third & 32) !== 0 && profile === 2 ? 12 : highBitDepth ? 10 : 8;
+	return `${format}.${profile}.${pad2(level)}${tier}.${pad2(depth)}`;
+}
+/**
+* `vp09.00.10.08`, out of the `vpcC` record.
+*
+* Here for the same reason the AV1 one is, and simpler: `vpcC` is a
+* full box, so a version and three flag bytes come first, and then the
+* profile, the level and a byte whose top four bits are the bit depth.
+*/
+function vp9CodecString(format, record) {
+	const profile = record[4];
+	const level = record[5];
+	const packed = record[6];
+	if (profile === void 0 || level === void 0 || packed === void 0) return format;
+	return `${format}.${pad2(profile)}.${pad2(level)}.${pad2(packed >> 4)}`;
+}
+function pad2(value) {
+	return value.toString(10).padStart(2, "0");
+}
 function hex2(value) {
 	return value.toString(16).padStart(2, "0").toUpperCase();
 }
 /**
+* The `trex` defaults, one per track, out of `moov`/`mvex`.
+*
+* `mvex`'s presence is also the honest test for a fragmented file. The
+* `moof` boxes are the fragments, but a file may legitimately have its
+* first fragment far enough in that a parser has not reached one yet,
+* whereas `mvex` is in the `moov` and says up front that fragments are
+* how this file is built.
+*/
+function readTrackExtends(reader, moov) {
+	const defaults = /* @__PURE__ */ new Map();
+	walkBoxes(reader, moov.start, moov.end, (box) => {
+		if (box.type !== "mvex") return;
+		walkBoxes(reader, box.start, box.end, (child) => {
+			if (child.type !== "trex") return;
+			readFullBoxVersion(reader);
+			const trackId = reader.u32();
+			reader.skip(4);
+			defaults.set(trackId, {
+				trackId,
+				defaultSampleDuration: reader.u32(),
+				defaultSampleSize: reader.u32(),
+				defaultSampleFlags: reader.u32()
+			});
+		});
+	});
+	return defaults;
+}
+/**
+* Builds a track's samples out of the file's fragments.
+*
+* A fragmented MP4 says nothing up front about where its samples are:
+* there is no `stco`, no `stsz` and no `stts`, and the `stbl` in the
+* `moov` is a shell holding only the `stsd`. Instead each `moof`
+* carries a `traf` per track, and each `traf` a `trun` per run of
+* samples, describing sizes and durations inline — with anything
+* omitted falling back to a default from `tfhd`, and failing that from
+* `trex`. So this is a walk rather than a table lookup, and it is why
+* the two shapes could not share `buildSamples`.
+*
+* **Offsets are the part that goes wrong.** A sample's position is
+* `base_data_offset` plus the `trun`'s own `data_offset` plus the
+* sizes of the samples before it in that run, and `base_data_offset`
+* is one of three things: written into the `tfhd`, or the start of
+* the enclosing `moof` when `default-base-is-moof` is set, or — for
+* the first `traf` — the `moof` again by the specification's older
+* rule. The second of those is what every fragmenter writes today and
+* what makes a fragment self-contained; taking the first `traf` rule
+* as the general one puts every fragment after the first at the wrong
+* offset, which decodes as noise rather than as an error.
+*
+* **Times accumulate across fragments.** `tfdt` states the decode time
+* a fragment starts at, and where it is absent the fragment continues
+* from wherever the last one ended.
+*/
+function buildFragmentedSamples(reader, moofs, table, defaults) {
+	const samples = [];
+	const trex = defaults.get(table.trackId);
+	let decodeTime = 0;
+	for (const moof of moofs) {
+		const moofStart = moof.start - 8;
+		walkBoxes(reader, moof.start, moof.end, (traf) => {
+			if (traf.type !== "traf") return;
+			let trackId = 0;
+			let baseDataOffset = moofStart;
+			let defaultDuration = trex?.defaultSampleDuration ?? 0;
+			let defaultSize = trex?.defaultSampleSize ?? 0;
+			let defaultFlags = trex?.defaultSampleFlags ?? 0;
+			const runs = [];
+			let fragmentTime = null;
+			walkBoxes(reader, traf.start, traf.end, (child) => {
+				if (child.type === "tfhd") {
+					const { flags } = readFullBox(reader);
+					trackId = reader.u32();
+					if ((flags & 1) !== 0) baseDataOffset = reader.u64();
+					if ((flags & 2) !== 0) reader.skip(4);
+					if ((flags & 8) !== 0) defaultDuration = reader.u32();
+					if ((flags & 16) !== 0) defaultSize = reader.u32();
+					if ((flags & 32) !== 0) defaultFlags = reader.u32();
+					return;
+				}
+				if (child.type === "tfdt") {
+					fragmentTime = readFullBoxVersion(reader) === 1 ? reader.u64() : reader.u32();
+					return;
+				}
+				if (child.type === "trun") runs.push({
+					header: child,
+					at: child.start
+				});
+			});
+			if (trackId !== table.trackId) return;
+			if (fragmentTime !== null) decodeTime = fragmentTime;
+			for (const run of runs) {
+				reader.offset = run.at;
+				const { version, flags } = readFullBox(reader);
+				const count = reader.u32();
+				let offset = baseDataOffset;
+				if ((flags & 1) !== 0) offset += reader.i32();
+				const firstFlags = (flags & 4) !== 0 ? reader.u32() : null;
+				for (let index = 0; index < count; index++) {
+					const duration = (flags & 256) !== 0 ? reader.u32() : defaultDuration;
+					const size = (flags & 512) !== 0 ? reader.u32() : defaultSize;
+					const sampleFlags = (flags & 1024) !== 0 ? reader.u32() : index === 0 && firstFlags !== null ? firstFlags : defaultFlags;
+					const composition = (flags & 2048) !== 0 ? version === 0 ? reader.i32() : reader.i32() : 0;
+					samples.push({
+						offset,
+						size,
+						timestampUs: Math.round((decodeTime + composition) * 1e6 / table.timescale),
+						durationUs: Math.round(duration * 1e6 / table.timescale),
+						isKey: (sampleFlags & 65536) === 0
+					});
+					offset += size;
+					decodeTime += duration;
+				}
+			}
+		});
+	}
+	return samples;
+}
+/**
 * Walks the sample tables into a flat list.
 *
 * The one piece of real arithmetic in this file: `stsc` describes runs
@@ -11600,6 +12270,148 @@ function buildSamples(table) {
 	return samples;
 }
 //#endregion
+//#region src/media/ByteSource.ts
+/** A file already in memory, which is every file this framework read before. */
+function bufferSource(data) {
+	return {
+		size: data.byteLength,
+		read(offset, size) {
+			if (offset < 0 || offset + size > data.byteLength) return null;
+			return new Uint8Array(data, offset, size);
+		},
+		request() {
+			return Promise.resolve();
+		},
+		close() {}
+	};
+}
+/**
+* How much is fetched at a time.
+*
+* Big enough that a request is worth its round trip — a quarter of a
+* megabyte is a second or two of ordinary video, so a clip playing
+* forwards asks for one every second or so rather than every frame —
+* and small enough that a seek does not drag a great deal of video
+* nobody will watch.
+*
+* It is also what a reader's first request should be, so that the
+* bytes it read to find the header land on a block boundary and can
+* be kept; see `prefetched`. A megabyte, the first value here, was
+* larger than the whole of a short file, so the header probe could
+* never seed a block and the front of the file was always fetched
+* twice.
+*/
+const DEFAULT_BLOCK_SIZE = 262144;
+/**
+* How many blocks to keep.
+*
+* Eight megabytes, which is enough that playing forwards never evicts
+* a block it is about to want, and a bound rather than a cache that
+* grows to the size of the file — which would make the whole exercise
+* pointless.
+*/
+const BLOCK_CAPACITY = 32;
+/**
+* A file fetched a block at a time.
+*
+* Blocks rather than exact ranges, and aligned to their own size, so
+* that two samples in the same part of the file share one request and
+* so the cache can be keyed on a number. A sample straddling a block
+* boundary is copied out of the two blocks either side of it; every
+* other read is a view, which matters because the common case is a
+* frame's worth of bytes on the way to a decoder.
+*
+* **Eviction is by last use, not by position.** A viewer who seeks
+* backwards into what they just watched should find it still here, and
+* a strictly forward-looking policy would have thrown it away.
+*/
+function rangeSource(source, options) {
+	const blockSize = options.blockSize ?? 262144;
+	const capacity = options.capacity ?? BLOCK_CAPACITY;
+	const blocks = /* @__PURE__ */ new Map();
+	const inFlight = /* @__PURE__ */ new Map();
+	let closed = false;
+	const blockOf = (offset) => Math.floor(offset / blockSize);
+	/** Slices whatever the caller already had into blocks this can serve. */
+	const seed = (start, data) => {
+		const bytes = new Uint8Array(data);
+		const end = start + bytes.length;
+		for (let index = Math.ceil(start / blockSize);; index++) {
+			const blockStart = index * blockSize;
+			const blockEnd = Math.min(blockStart + blockSize, options.size);
+			if (blockEnd > end) break;
+			blocks.set(index, bytes.subarray(blockStart - start, blockEnd - start));
+			if (blockEnd === options.size) break;
+		}
+	};
+	/** Marks a block as the most recently used, which a Map's order gives us for free. */
+	const touch = (index, bytes) => {
+		blocks.delete(index);
+		blocks.set(index, bytes);
+		while (blocks.size > capacity) {
+			const oldest = blocks.keys().next();
+			if (oldest.done === true) break;
+			blocks.delete(oldest.value);
+		}
+	};
+	const fetchBlock = (index) => {
+		const existing = inFlight.get(index);
+		if (existing !== void 0) return existing;
+		const start = index * blockSize;
+		const end = Math.min(start + blockSize, options.size);
+		const request = options.fetchRange(source, start, end).then((buffer) => {
+			if (closed) return;
+			touch(index, new Uint8Array(buffer));
+		}).finally(() => inFlight.delete(index));
+		inFlight.set(index, request);
+		return request;
+	};
+	if (options.prefetched !== void 0) seed(options.prefetched.start, options.prefetched.data);
+	return {
+		size: options.size,
+		read(offset, size) {
+			if (offset < 0 || size < 0 || offset + size > options.size) return null;
+			const first = blockOf(offset);
+			const last = blockOf(offset + Math.max(0, size - 1));
+			const head = blocks.get(first);
+			if (head === void 0) return null;
+			if (first === last) {
+				touch(first, head);
+				return head.subarray(offset - first * blockSize, offset - first * blockSize + size);
+			}
+			const out = new Uint8Array(size);
+			let written = 0;
+			for (let index = first; index <= last; index++) {
+				const block = blocks.get(index);
+				if (block === void 0) return null;
+				const blockStart = index * blockSize;
+				const from = Math.max(0, offset - blockStart);
+				const take = Math.min(block.length - from, size - written);
+				out.set(block.subarray(from, from + take), written);
+				written += take;
+			}
+			for (let index = first; index <= last; index++) {
+				const block = blocks.get(index);
+				if (block !== void 0) touch(index, block);
+			}
+			return written === size ? out : null;
+		},
+		async request(offset, size) {
+			if (closed || offset < 0 || offset >= options.size) return;
+			const first = blockOf(offset);
+			const last = blockOf(Math.min(offset + Math.max(0, size - 1), options.size - 1));
+			const wanted = [];
+			for (let index = first; index <= last; index++) if (!blocks.has(index)) wanted.push(fetchBlock(index));
+			await Promise.all(wanted);
+		},
+		close() {
+			closed = true;
+			blocks.clear();
+			inFlight.clear();
+		}
+	};
+}
+//#endregion
 //#region src/media/VideoResolver.ts
 /** Whether this thread can decode video at all. */
 function canDecodeVideo() {
@@ -11657,10 +12469,12 @@ var DefaultVideoResolver = class {
 	evictable = [];
 	capacity;
 	fetchBuffer;
+	fetchRange;
 	disposed = false;
 	constructor(options = {}) {
 		this.capacity = options.capacity ?? DEFAULT_CAPACITY;
 		this.fetchBuffer = options.fetch ?? defaultFetch;
+		this.fetchRange = options.fetchRange;
 	}
 	/** Live or in-flight sources, for specs and the inspector. */
 	get size() {
@@ -11716,13 +12530,103 @@ var DefaultVideoResolver = class {
 	}
 	async open(source) {
 		if (!canDecodeVideo()) throw new Error("This thread has no WebCodecs VideoDecoder, so video cannot be played here. It is available in Chrome 94+ and in a worker; Safari and Firefox support varies.");
-		const data = await this.fetchBuffer(source);
-		const playback = new Mp4Playback(demuxMp4Video(data), data);
+		const bytes = this.fetchRange === void 0 ? await this.openWhole(source) : await this.openRanged(source);
+		const playback = new Mp4Playback(bytes.track, bytes.data);
 		await playback.start();
 		return playback;
 	}
+	async openWhole(source) {
+		const data = await this.fetchBuffer(source);
+		return {
+			track: demuxMp4Video(data),
+			data: bufferSource(data)
+		};
+	}
+	/**
+	* Finds the `moov`, reads it, and leaves the media where it is.
+	*
+	* The top-level structure of an MP4 is a flat list of boxes, each of
+	* which states its own length, so the whole of it can be walked by
+	* reading eight bytes at a time and jumping — which means finding
+	* the `moov` costs a couple of small requests whether it is at the
+	* front of the file (`-movflags +faststart`, and every file served
+	* for streaming) or at the back (the default, and every file written
+	* by a camera).
+	*
+	* The `moov` is then demuxed *on its own*, which works because the
+	* offsets in a sample table are absolute positions in the file
+	* rather than relative to anything: the tables are as correct read
+	* out of a two hundred kilobyte buffer as out of a gigabyte one.
+	*/
+	async openRanged(source) {
+		const fetchRange = this.fetchRange;
+		const first = await fetchRange(source, 0, HEADER_PROBE_BYTES);
+		const total = first.total;
+		if (!Number.isFinite(total) || total <= 0) throw new Error(`Fetching a range of '${source}' did not report how long the file is.`);
+		const plain = (start, end) => fetchRange(source, start, end).then((response) => response.data);
+		const bytes = rangeSource(source, {
+			fetchRange: (_source, start, end) => plain(start, end),
+			size: total,
+			prefetched: {
+				start: 0,
+				data: first.data
+			}
+		});
+		const moov = await findTopLevelBox(bytes, "moov", total);
+		if (moov === null) throw new Error(`'${source}' has no moov box, so there is no sample table to read. A ranged read walks the top-level boxes; a file this cannot walk is not an MP4.`);
+		const held = bytes.read(moov.start, moov.end - moov.start);
+		return {
+			track: demuxMp4Video(held === null ? await plain(moov.start, moov.end) : held.slice().buffer),
+			data: bytes
+		};
+	}
 };
 /**
+* How much of the front of the file to ask for first.
+*
+* Exactly one block, and that is the whole point of the constant
+* rather than a number here: a probe that does not land on a block
+* boundary cannot be kept, so the front of the file would be fetched
+* once to find the header and again as the first block. It is also
+* enough to hold the `ftyp` and, in a faststart file, the whole `moov`
+* for a clip of ordinary length, so the common case is a single
+* request for the whole header.
+*/
+const HEADER_PROBE_BYTES = DEFAULT_BLOCK_SIZE;
+/**
+* Walks the top-level boxes looking for one, reading only their
+* headers.
+*
+* A box states its own length, so the walk is a jump per box and the
+* bytes it touches are sixteen at a time. `size === 1` means the real
+* length is a 64-bit number after the type, and `size === 0` means the
+* box runs to the end of the file — both of which `mdat` is written
+* with often enough to matter.
+*/
+async function findTopLevelBox(bytes, wanted, total) {
+	let at = 0;
+	while (at + 8 <= total) {
+		await bytes.request(at, 16);
+		const header = bytes.read(at, Math.min(16, total - at));
+		if (header === null || header.length < 8) return null;
+		const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+		let size = view.getUint32(0);
+		let payload = at + 8;
+		if (size === 1) {
+			if (header.length < 16) return null;
+			size = view.getUint32(8) * 4294967296 + view.getUint32(12);
+			payload = at + 16;
+		} else if (size === 0) size = total - at;
+		if (size < 8 || at + size > total) return null;
+		if (String.fromCharCode(header[4], header[5], header[6], header[7]) === wanted) return {
+			start: payload - 8,
+			end: at + size
+		};
+		at += size;
+	}
+	return null;
+}
+/**
 * One MP4, decoded and presented against the runtime's frame clock.
 *
 * The clock matters. Nothing here uses `setInterval` or the decoder's
@@ -11746,10 +12650,35 @@ var Mp4Playback = class {
 	positionUs = 0;
 	closed = false;
 	errorListeners = /* @__PURE__ */ new Set();
+	frameListeners = /* @__PURE__ */ new Set();
+	/**
+	* The sync samples, by presentation time, so a seek can find where
+	* to start decoding with a binary search rather than a scan.
+	*
+	* Built once, because `samples` never changes and a scrub drags
+	* across it many times a second. Sorted by `timestampUs` rather than
+	* left in decode order: a keyframe carries a composition offset like
+	* any other sample, so the order they are *shown* in is the order a
+	* seek searches, and it is not quite the order they are decoded in.
+	*/
+	syncPoints;
+	/**
+	* Where a seek is aiming, in microseconds, or null when playing
+	* forwards.
+	*
+	* Frames that arrive before this are decoded only because the
+	* pictures after them refer to them, and are closed on arrival
+	* instead of being queued — see `receive`. Cleared as soon as a
+	* frame at or past it has been decoded.
+	*/
+	seekTargetUs = null;
+	/** Whether a fetch for missing bytes is already out; see `await`. */
+	pendingBytes = false;
 	constructor(track, data) {
 		this.track = track;
 		this.data = data;
-		this.surface = new MutableVideoSurface(track.codedWidth, track.codedHeight);
+		this.surface = new MutableVideoSurface(track.codedWidth, track.codedHeight, () => this.announcePicture());
+		this.syncPoints = buildSyncPoints(track.samples);
 		this.decoder = new VideoDecoder({
 			output: (frame) => this.receive(frame),
 			error: (error) => this.fail(error)
@@ -11770,6 +12699,9 @@ var Mp4Playback = class {
 	get positionMs() {
 		return this.positionUs / 1e3;
 	}
+	get seeking() {
+		return this.seekTargetUs !== null;
+	}
 	async start() {
 		const config = {
 			codec: this.track.codec,
@@ -11795,7 +12727,7 @@ var Mp4Playback = class {
 		if (this.closed) return false;
 		const wanted = Math.max(0, positionMs * 1e3);
 		if (wanted === this.positionUs) return false;
-		if (wanted + SEEK_BACK_TOLERANCE_US < this.positionUs) this.rewind();
+		if (this.needsSeek(wanted)) this.seekTo(wanted);
 		this.positionUs = wanted;
 		const changed = this.presentDue();
 		this.fill();
@@ -11805,6 +12737,10 @@ var Mp4Playback = class {
 		this.errorListeners.add(listener);
 		return () => this.errorListeners.delete(listener);
 	}
+	onFrame(listener) {
+		this.frameListeners.add(listener);
+		return () => this.frameListeners.delete(listener);
+	}
 	/** Frees the decoder and every frame still queued. */
 	close() {
 		if (this.closed) return;
@@ -11814,6 +12750,8 @@ var Mp4Playback = class {
 		this.surface.clear();
 		if (this.decoder.state !== "closed") this.decoder.close();
 		this.errorListeners.clear();
+		this.frameListeners.clear();
+		this.data.close();
 	}
 	presentDue() {
 		let shown = false;
@@ -11831,14 +12769,30 @@ var Mp4Playback = class {
 		}
 		return shown;
 	}
-	/** Keeps the decoder a few frames ahead, and no further. */
+	/**
+	* Keeps the decoder a few frames ahead, and no further.
+	*
+	* **Stops at the first sample whose bytes are not here yet**, which
+	* is the whole of what a ranged source costs this loop. `read`
+	* answers synchronously or not at all — see `ByteSource` for why it
+	* must — so a sample that is still on the wire ends the fill, a
+	* request goes out for the region around it, and that request
+	* calls `fill` again when it lands. In the ordinary case, a file
+	* already in memory, `read` never answers null and none of this
+	* runs.
+	*/
 	fill() {
 		if (this.closed || this.decoder.state !== "configured") return;
 		while (this.nextSample < this.track.samples.length && this.queue.length + this.decoder.decodeQueueSize < FRAME_QUEUE_LIMIT) {
 			const sample = this.track.samples[this.nextSample];
+			const bytes = this.data.read(sample.offset, sample.size);
+			if (bytes === null) {
+				this.await(sample);
+				return;
+			}
 			this.nextSample++;
 			try {
-				this.decoder.decode(new EncodedVideoChunk(chunkOf(sample, this.data)));
+				this.decoder.decode(new EncodedVideoChunk(chunkOf(sample, bytes)));
 			} catch (error) {
 				this.fail(error);
 				return;
@@ -11846,21 +12800,77 @@ var Mp4Playback = class {
 		}
 	}
 	/**
-	* Back to the start of the stream.
+	* Asks for the bytes around a sample, and resumes when they arrive.
+	*
+	* The window is deliberately wider than the one sample: a request
+	* per frame would be a request every sixteen milliseconds, and the
+	* point of reading a file in pieces is to read it in *few* pieces.
+	* So it asks for everything from this sample to the end of the
+	* decoder's lookahead, which the block size below it will round up
+	* to something worth a round trip anyway.
+	*/
+	await(sample) {
+		if (this.pendingBytes) return;
+		const last = this.track.samples[Math.min(this.nextSample + FRAME_QUEUE_LIMIT, this.track.samples.length - 1)];
+		const through = last === void 0 ? sample.offset + sample.size : last.offset + last.size;
+		this.pendingBytes = true;
+		this.data.request(sample.offset, Math.max(sample.size, through - sample.offset)).then(() => {
+			this.pendingBytes = false;
+			if (this.closed) return;
+			this.fill();
+			this.announceFrame();
+		}).catch((error) => {
+			this.pendingBytes = false;
+			this.fail(error);
+		});
+	}
+	/**
+	* Whether reaching `wanted` means starting the decoder somewhere
+	* else.
+	*
+	* Two cases, and they are not symmetric. **Backwards** past the
+	* tolerance is always a seek: a decoder cannot run in reverse, so
+	* every frame in flight belongs to where we no longer are. It is
+	* also what a loop is, which is why looping costs a keyframe.
+	*
+	* **Forwards** is a seek only when the jump clears the samples
+	* already submitted. During ordinary playback the decoder runs a few
+	* frames ahead of the picture, so the keyframe covering the position
+	* is always one it has long since passed — `sample <= nextSample`,
+	* and nothing happens. A jump far enough ahead to land beyond the
+	* decoder's own head is the only forward case worth a reset, and
+	* without this test it would instead decode every frame in between
+	* at playback speed, which is a scrub that crawls.
+	*/
+	needsSeek(wanted) {
+		if (wanted + SEEK_BACK_TOLERANCE_US < this.positionUs) return true;
+		if (wanted <= this.positionUs) return false;
+		return syncSampleFor(this.syncPoints, wanted) > this.nextSample;
+	}
+	/**
+	* Starts the decoder again at the sync sample covering `wanted`.
 	*
 	* The decoder is reset and reconfigured rather than merely refilled,
 	* because a decoder mid-GOP holds reference frames for where it was
-	* and the first sample of the file is a keyframe for where it is
-	* going. That costs one keyframe decode at the loop point — a
-	* measurable hitch on a long GOP, invisible on the two-second ones
-	* a looping clip is usually encoded with — and it is the honest
-	* price of looping a progressive file rather than a fragmented one.
-	*/
-	rewind() {
+	* and the sample it is about to be given is a keyframe for where it
+	* is going.
+	*
+	* What lands is the keyframe *at or before* the wanted position,
+	* never after: a seek that jumped forward to the next keyframe would
+	* show a picture from later than the moment asked for, and a scrubber
+	* that overshoots its own thumb is worse than one that is coarse.
+	* The frames between the keyframe and the target are decoded — the
+	* ones after it refer to them — and closed on arrival rather than
+	* queued, which is what `seekTargetUs` is for. So the cost of a seek
+	* is the GOP length, paid in decodes nobody sees, and the reason a
+	* clip encoded with two-second keyframes scrubs well and one encoded
+	* with ten-second keyframes does not.
+	*/
+	seekTo(wanted) {
 		for (const frame of this.queue) frame.close();
 		this.queue.length = 0;
-		this.nextSample = 0;
-		this.positionUs = 0;
+		this.nextSample = syncSampleFor(this.syncPoints, wanted);
+		this.seekTargetUs = wanted > 0 ? wanted : null;
 		if (this.config !== null && this.decoder.state !== "closed") {
 			this.decoder.reset();
 			this.decoder.configure(this.config);
@@ -11871,20 +12881,92 @@ var Mp4Playback = class {
 			frame.close();
 			return;
 		}
+		const target = this.seekTargetUs;
+		if (target !== null) {
+			if (frame.timestamp + this.track.frameDurationUs < target) {
+				frame.close();
+				this.fill();
+				return;
+			}
+			this.enqueue(frame);
+			if (!(frame.timestamp >= target || this.nextSample >= this.track.samples.length)) {
+				this.fill();
+				return;
+			}
+			this.seekTargetUs = null;
+			this.announceFrame();
+			return;
+		}
+		this.enqueue(frame);
+		this.announceFrame();
+	}
+	/** Queued in presentation order; see `presentDue` for why that matters. */
+	enqueue(frame) {
 		this.queue.push(frame);
 		this.queue.sort((a, b) => a.timestamp - b.timestamp);
 	}
+	/**
+	* Presents whatever is due, and lets the surface say if that put a
+	* picture up: see the constructor for why the two are not the same
+	* moment.
+	*/
+	announceFrame() {
+		this.presentDue();
+	}
+	announcePicture() {
+		for (const listener of this.frameListeners) listener();
+	}
 	fail(error) {
 		for (const listener of this.errorListeners) listener(error);
 		this.close();
 	}
 };
-function chunkOf(sample, data) {
+/**
+* The track's sync samples, in the order they are shown.
+*
+* `samples` is in decode order and stays that way — feeding a decoder
+* anything else is how you submit a frame before the one it refers to
+* — so the search a seek does needs its own view. Only the sync
+* samples are in it, which for a two-second GOP is one entry per two
+* seconds: a fifteen-minute film indexes in a few hundred numbers.
+*/
+function buildSyncPoints(samples) {
+	const points = [];
+	for (const [sample, entry] of samples.entries()) if (entry.isKey) points.push({
+		timestampUs: entry.timestampUs,
+		sample
+	});
+	points.sort((a, b) => a.timestampUs - b.timestampUs);
+	return points;
+}
+/**
+* Which sample to start decoding at to have a picture for `wanted`.
+*
+* The last sync sample at or before the position, by binary search.
+* Zero when the position is before the first one, or when the track
+* declared no sync samples at all — an all-intra track, where every
+* sample is one and `buildSyncPoints` returned all of them anyway.
+*/
+function syncSampleFor(points, wantedUs) {
+	let low = 0;
+	let high = points.length - 1;
+	let found = 0;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const point = points[middle];
+		if (point.timestampUs <= wantedUs) {
+			found = point.sample;
+			low = middle + 1;
+		} else high = middle - 1;
+	}
+	return found;
+}
+function chunkOf(sample, bytes) {
 	return {
 		type: sample.isKey ? "key" : "delta",
 		timestamp: sample.timestampUs,
 		duration: sample.durationUs,
-		data: new Uint8Array(data, sample.offset, sample.size)
+		data: bytes
 	};
 }
 /**
@@ -11897,11 +12979,13 @@ function chunkOf(sample, data) {
 var MutableVideoSurface = class {
 	width;
 	height;
+	onPicture;
 	frame = null;
 	version = 0;
-	constructor(width, height) {
+	constructor(width, height, onPicture = () => {}) {
 		this.width = width;
 		this.height = height;
+		this.onPicture = onPicture;
 	}
 	/**
 	* Which conversion is the newest, so a slower one that finishes
@@ -11957,6 +13041,7 @@ var MutableVideoSurface = class {
 		this.frame?.close?.();
 		this.frame = frame;
 		this.version++;
+		this.onPicture();
 	}
 	clear() {
 		this.pending++;
@@ -11966,6 +13051,154 @@ var MutableVideoSurface = class {
 	}
 };
 //#endregion
+//#region src/media/WebVtt.ts
+const EMPTY_SETTINGS = Object.freeze({});
+/**
+* Reads a `.vtt` file.
+*
+* Returns an empty track rather than throwing for a file that is not
+* WebVTT at all, for the reason the docblock gives: a caption track is
+* an enhancement, and an application that has to guard every one of
+* these with a `try` will end up not showing captions at all.
+*/
+function parseWebVtt(source) {
+	const lines = source.replace(/^/, "").split(/\r\n|\r|\n/);
+	const first = lines[0] ?? "";
+	if (!first.startsWith("WEBVTT")) return {
+		cues: [],
+		header: "",
+		skipped: 0
+	};
+	const header = first.slice(6).trim();
+	const cues = [];
+	let skipped = 0;
+	let at = 1;
+	while (at < lines.length) {
+		while (at < lines.length && (lines[at] ?? "").trim() === "") at++;
+		if (at >= lines.length) break;
+		const blockStart = at;
+		const block = [];
+		while (at < lines.length && (lines[at] ?? "").trim() !== "") {
+			block.push(lines[at]);
+			at++;
+		}
+		const cue = readBlock(block);
+		if (cue === null) {
+			if (!isIgnorableBlock(block)) skipped++;
+		} else cues.push(cue);
+		if (at === blockStart) at++;
+	}
+	cues.sort((a, b) => a.start - b.start || a.end - b.end);
+	return {
+		cues,
+		header,
+		skipped
+	};
+}
+function isIgnorableBlock(block) {
+	const first = (block[0] ?? "").trim();
+	return first === "NOTE" || first.startsWith("NOTE ") || first === "STYLE" || first === "REGION";
+}
+function readBlock(block) {
+	if (block.length === 0 || isIgnorableBlock(block)) return null;
+	const timingIndex = block.findIndex((line) => line.includes("-->"));
+	if (timingIndex === -1 || timingIndex > 1) return null;
+	const id = timingIndex === 1 ? block[0].trim() : void 0;
+	const timing = block[timingIndex];
+	const arrow = timing.indexOf("-->");
+	const start = parseTimestamp(timing.slice(0, arrow));
+	const rest = timing.slice(arrow + 3).trim();
+	const space = rest.search(/\s/);
+	const end = parseTimestamp(space === -1 ? rest : rest.slice(0, space));
+	if (start === null || end === null || end < start) return null;
+	const settings = space === -1 ? EMPTY_SETTINGS : parseSettings(rest.slice(space + 1));
+	const payload = block.slice(timingIndex + 1);
+	if (payload.length === 0) return null;
+	return {
+		id,
+		start,
+		end,
+		text: stripMarkup(payload.join("\n")),
+		settings
+	};
+}
+/**
+* `hh:mm:ss.mmm` or `mm:ss.mmm`, into seconds.
+*
+* Null rather than NaN for anything else, so a caller cannot
+* accidentally propagate a number that compares false against
+* everything.
+*/
+function parseTimestamp(text) {
+	const match = /^\s*(?:(\d+):)?([0-5]\d):([0-5]\d)[.,](\d{1,3})\s*$/.exec(text);
+	if (match === null) return null;
+	const hours = match[1] === void 0 ? 0 : Number(match[1]);
+	const minutes = Number(match[2]);
+	const seconds = Number(match[3]);
+	const fraction = Number(match[4].padEnd(3, "0")) / 1e3;
+	return hours * 3600 + minutes * 60 + seconds + fraction;
+}
+function parseSettings(text) {
+	const settings = {};
+	for (const pair of text.split(/\s+/)) {
+		const colon = pair.indexOf(":");
+		if (colon <= 0) continue;
+		settings[pair.slice(0, colon)] = pair.slice(colon + 1);
+	}
+	return Object.keys(settings).length === 0 ? EMPTY_SETTINGS : settings;
+}
+/**
+* Takes the tags out and leaves the words.
+*
+* Entities are decoded for the five WebVTT names only. There is no
+* general entity table here on purpose: the full set belongs to HTML,
+* a caption file that carries one is relying on a document context
+* this has none of, and the five below are the ones a caption actually
+* needs — a stray `<` in dialogue has to be escaped, and `&nbsp;` is
+* written by tools that think they are writing HTML.
+*/
+function stripMarkup(text) {
+	return text.replace(/<[^>]*>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&lrm;|&rlm;/g, "").replace(/&nbsp;/g, "\xA0").replace(/&amp;/g, "&").trim();
+}
+/**
+* The cue to show at a position, or null between cues.
+*
+* A linear scan from a hint rather than a binary search, and that is
+* the right shape here rather than a concession: this is called once
+* per frame with a position that has almost always moved by one frame,
+* so the answer is nearly always the cue it was last time or the one
+* after it. `from` is that hint — pass back the index this returned —
+* and the scan is then O(1) for playback and O(n) only for a scrub,
+* where a caption is not what is costing anything.
+*
+* **Overlapping cues.** WebVTT permits them and a transcript of two
+* people talking over each other has them. This answers the one that
+* *starts* latest among those covering the position, which is what a
+* single-line caption should show: the newest thing said.
+*/
+function cueAt(cues, seconds, from = 0) {
+	if (cues.length === 0) return {
+		cue: null,
+		index: 0
+	};
+	let index = Math.min(Math.max(0, from), cues.length - 1);
+	while (index > 0 && cues[index].start > seconds) index--;
+	let best = null;
+	let bestIndex = index;
+	for (let n = index; n < cues.length; n++) {
+		const cue = cues[n];
+		if (cue.start > seconds) break;
+		if (cue.end > seconds) {
+			best = cue;
+			bestIndex = n;
+		}
+	}
+	return {
+		cue: best,
+		index: best === null ? index : bestIndex
+	};
+}
+//#endregion
 //#region src/scheduler/PerformanceMarks.ts
 /**
 * Gesso's work, in the browser's own profiler
@@ -12393,20 +13626,38 @@ var UiTimerFrameClock = class {
 /**
 * A clock whose frames arrive from somewhere else.
 *
-* The one thing a worker cannot do for itself. `requestAnimationFrame`
-* is tied to the compositor and exists only on the main thread, so a
-* render worker's frames were paced by `UiTimerFrameClock` at a fixed
-* 16ms — roughly sixty a second on any display, aligned to none of
-* them. On a 165Hz monitor that is not merely slower than it could be:
-* an unaligned timer lands two frames inside one refresh, or none, so
-* the pacing is uneven as well as capped.
-*
-* This clock does no timing at all. It reports when it wants frames
-* and delivers whatever ticks it is handed, which lets the shell —
-* the one thread with a `requestAnimationFrame` — supply the display's
-* own cadence. That is the narrow exception to keeping the shell
-* uninvolved: not work moved back onto the main thread for
-* convenience, but the single fact a worker has no way to observe.
+* A render worker's frames were once paced by `UiTimerFrameClock` at a
+* fixed 16ms — roughly sixty a second on any display, aligned to none
+* of them. On a 165Hz monitor that is not merely slower than it could
+* be: an unaligned timer lands two frames inside one refresh, or none,
+* so the pacing is uneven as well as capped.
+*
+* **A dedicated worker can ask the compositor itself**, and this clock
+* does so when it can. `DedicatedWorkerGlobalScope.requestAnimationFrame`
+* has been in Chrome since 69, Firefox since 99 and Safari since 16.4,
+* which makes it baseline as of March 2023; this file used to say it
+* "exists only on the main thread", which was true when it was written
+* and is not now. Measured in the render worker: a median interval of
+* 16.7ms with a spread of 0.2, which is vsync and not a timer. Its
+* timestamps are on this thread's own `performance.now()` timeline, so
+* nothing has to be translated.
+*
+* That path costs the shell nothing at all: no loop, and no message
+* per refresh. `onActive` is never called, so a host that was
+* forwarding ticks simply stops being asked to.
+*
+* **The hosted path remains for where it is not available**, which is
+* an older browser and, on Chromium, a *nested* worker. Then this
+* clock does no timing of its own: it reports when it wants frames and
+* delivers whatever ticks it is handed, which lets the shell supply
+* the display's cadence on its behalf. It is the same contract either
+* way, which is why the choice can be made at construction and
+* forgotten.
+*
+* Both paths stop for a hidden tab, and that is not a coincidence: a
+* worker's animation frames are serviced by its **owner window's**
+* rendering, and a window that is not rendering services none. So the
+* battery properties the runtime relies on hold whichever path runs.
 *
 * **Ticks are free-running while frames are wanted, not requested one
 * at a time.** A tick per request would cost a round trip inside every
@@ -12417,6 +13668,18 @@ var UiTimerFrameClock = class {
 * one comparison and makes the timing robust to whichever side is
 * late.
 */
+/**
+* This thread's `requestAnimationFrame`, if it has a real one.
+*
+* Checked for rather than assumed, because the answer differs by
+* thread and by browser: a window always has one, a dedicated worker
+* has had one for years, and a *nested* worker on Chromium has not.
+* The feature test is the whole guard; there is no version to compare.
+*/
+function localAnimationFrame() {
+	const host = globalThis;
+	return typeof host.requestAnimationFrame === "function" ? host.requestAnimationFrame.bind(host) : null;
+}
 var UiHostFrameClock = class {
 	onFrame;
 	onActive;
@@ -12455,6 +13718,9 @@ var UiHostFrameClock = class {
 	stallMs;
 	minStallMs;
 	now;
+	/** This thread's own `requestAnimationFrame`, or null where there is none. */
+	local;
+	localHandle = null;
 	constructor(onFrame, onActive, options = {}) {
 		this.onFrame = onFrame;
 		this.onActive = onActive;
@@ -12462,9 +13728,21 @@ var UiHostFrameClock = class {
 		this.stallMs = options.stallMs ?? 100;
 		this.minStallMs = options.minStallMs ?? 12;
 		this.now = options.now ?? (() => performance.now());
+		this.local = options.requestAnimationFrame === void 0 ? localAnimationFrame() : options.requestAnimationFrame;
+	}
+	/** Whether this clock is driving itself from the compositor. */
+	get isLocal() {
+		return this.local !== null;
 	}
 	requestFrame() {
 		this.pending = true;
+		if (this.local !== null) {
+			if (this.localHandle === null) this.localHandle = this.local((time) => {
+				this.localHandle = null;
+				if (this.pending) this.deliver(time);
+			});
+			return;
+		}
 		this.setActive(true);
 		this.armTimer();
 	}
@@ -12573,7 +13851,7 @@ var UiHostFrameClock = class {
 	cancelFrame() {
 		this.pending = false;
 		this.clearFallback();
-		this.setActive(false);
+		if (this.local === null) this.setActive(false);
 	}
 	clearFallback() {
 		if (this.handle !== null) {
@@ -13108,6 +14386,39 @@ const PRESENTATIONAL_CHILDREN = /* @__PURE__ */ new Set([
 *      hidden is not.
 */
 function buildSemanticsTree(root) {
+	return walk(root, null, false);
+}
+/**
+* The records one subtree contributes, as if walked in place.
+*
+* For re-describing what changed without rebuilding the whole tree.
+* `node` keeps the `parent` and `index` its existing record has, and
+* everything below it is walked exactly as `buildSemanticsTree` would:
+* a descendant's index is counted among the semantic children of
+* whatever inside this subtree claims it, so the numbering is the same
+* one a full walk produces.
+*
+* **That only holds when `node` itself carries a record.** A
+* transparent node's children attach to its nearest semantic ancestor
+* and are numbered among that ancestor's *other* children too — nodes
+* outside this subtree — so a walk that started here would number them
+* from zero and disagree with the tree. Null says so, and the caller
+* has to rebuild the whole tree instead.
+*
+* `inert` is whether an ancestor above this subtree is disabled, which
+* only the caller can know.
+*/
+function buildSemanticsSubtree(node, parent, index, inert) {
+	const records = walk(node, parent, inert);
+	const own = records.get(node.id);
+	if (own === void 0) return null;
+	records.set(node.id, {
+		...own,
+		index
+	});
+	return records;
+}
+function walk(root, rootParent, rootInert) {
 	const records = /* @__PURE__ */ new Map();
 	const childCounts = /* @__PURE__ */ new Map();
 	const nextIndex = (parent) => {
@@ -13133,18 +14444,29 @@ function buildSemanticsTree(root) {
 			visit(child, record.id, disabled);
 		}
 	};
-	visit(root, null, false);
+	visit(root, rootParent, rootInert);
 	return records;
 }
 /**
+* Whether an ancestor of `node` is disabled, which every record in its
+* subtree inherits.
+*
+* A full walk carries this down; a subtree walk has to look it up.
+*/
+function semanticsInertAbove(node) {
+	for (let current = node.parent; current !== null; current = current.parent) if (current.properties.get("disabled") === true) return true;
+	return false;
+}
+/**
 * The record for a node, or null when the node is transparent.
 */
 function describe(node, parent, disabled, nextIndex) {
 	const role = node.properties.get("role") ?? IMPLICIT_ROLES[node.type];
 	const declaredLabel = node.properties.get("label");
-	const name = declaredLabel ?? accessibleText(node);
 	const isText = node.type === "text";
-	if (role === void 0 && declaredLabel === void 0 && !(isText && name !== void 0)) return null;
+	if (role === void 0 && declaredLabel === void 0 && !isText) return null;
+	const name = declaredLabel ?? accessibleText(node);
+	if (role === void 0 && declaredLabel === void 0 && name === void 0) return null;
 	const states = node.properties.get("states");
 	return prune({
 		id: node.id,
@@ -13345,6 +14667,6 @@ function recordsEqual(a, b) {
 	return true;
 }
 //#endregion
-export { AlignContent, AnimationDriver, BUTTON_INTERACTION, Box, Button, CARET_BLINK_MS, CARET_WIDTH, CLIP_STRIDE_BYTES, CLIP_STRIDE_FLOATS, Canvas2DRenderer, CanvasPlatformSurface, CanvasSurface, CanvasTextMeasurer, CharacterCountTextMeasurer, Column, CommandKind, Constraints, CrossAxisAlignment, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_WEIGHT, DEFAULT_LINE_HEIGHT_FACTOR, DEFAULT_TEXT_COLOR, DefaultImageResolver, DefaultVideoResolver, DirtyFlags, DirtyNodeSet, EDITOR_PROP, ELLIPSIS, EMPTY_RECORDING, EXTERNAL_FILES, EditableLayout, EditableText, EditableTextModel, EnvironmentNotifier, FlexDirection, FocusNotifier, GLYPH_SUBPIXEL_PHASES, GlyphShaper, Grid, INSPECTOR_HEAT_MS, INSTANCE_STRIDE_BYTES, INSTANCE_STRIDE_FLOATS, IconRasterizer, LABEL_PADDING_X, LayoutEngine, LayoutInspector, LayoutNotifier, LayoutRecord, LazyColumn, LazyGrid, LazyRow, MARK_PREFIX, MAX_GRADIENT_STOPS, MAX_MEASURES_PER_CHILD, MOTION_CHANNELS, MOTION_REST, MOUSE_POINTER, MainAxisAlignment, Mp3Frames, NO_CLIP_INDEX, NodeTransitions, Paint, PaintPictureCache, PaintRecorder, PaintTarget, ParagraphTextMeasurer, PrimitiveKind, Responsive, Row, SCROLLBAR_FADE_MS, SCROLLBAR_HOVER_ZONE, SCROLLBAR_INSET, SCROLLBAR_LINGER_MS, SCROLLBAR_MIN_THUMB, SCROLLBAR_THICKNESS, ScrollView, Stack, TEXTURED_STRIDE_BYTES, TEXTURED_STRIDE_FLOATS, TEXT_MATCHES_PROP, TEXT_RUN_ID_SEPARATOR, TEXT_SELECTION_PROP, Text, UI_ROLES, UI_SEMANTIC_STATES, UI_SUBGRID_AXES, UiAnimation, UiAnimationFrameClock, UiBasicColors, UiBeforeInputEvent, UiBinding, UiBorderRadiuses, UiChildrenBinding, UiContainerSizeSource, UiDragSession, UiEditingController, UiEnvironment, UiEnvironmentKeys, UiEventBinding, UiEventType, UiFindController, UiFocusEvent, UiFocusManager, UiFrame, UiGestureEvent, UiGestureRecognizer, UiGraph, UiGraphBuilder, UiHitTester, UiHostFrameClock, UiInputDispatcher, UiInputEvent, UiInsetRegistry, UiKeyboardController, UiKeyboardEvent, UiManualFrameClock, UiModifierSet, UiNode, UiNodeType, UiPinchEvent, UiPinchRecognizer, UiPlatformAdapter, UiPointerController, UiPointerEvent, UiProperties, UiScheduler, UiSelectionController, UiSharedElements, UiShortcutRegistry, UiSpring, UiTextChangeEvent, UiTimerFrameClock, UiTouchScroller, UiTransforms, UiTween, UiUnknownModifierPropertyError, UiVirtualWindow, UiVisualState, UiWheelController, UiWheelDeltaMode, UiWheelEvent, VIRTUAL_INDEX_PROP, VIRTUAL_LEAD_PROP, VIRTUAL_WINDOW_PROP, WebGPUError, WebGPUGlyphAtlas, WebGPUGlyphPages, WebGPURenderer, WebGPUSurface, WebGPUTextureCache, accumulatedOffsetTo, animateLayout, applyCanvasTextStyle, assertModifierList, assertTransitionMap, auto, autoFocus, bandOf, borderRadius, borderRadiusCorners, borderRadiusEqual, borderRadiusIsZero, borderRadiusValuesEqual, boxShadow, boxShadowArraysEqual, boxShadowsEqual, breakpoint, buildFontString, buildRenderList, buildSemanticsTree, bumpFontStack, bundle, canDecodeVideo, capturePointer, caretRectFor, caretVisibleAt, clampSize, clearFontStacks, clearLinkHover, clearMatchRanges, clearOverrideProperty, clearSelectionRange, clickOutside, closestPropertyName, colorToCss, colorToHex, colorToRgba, colorValuesEqual, colorsEqual, colorsEqualPalette, commandForKey, computeObjectFitRect, constraintsEqual, containerBands, contentOffset, contextMenu, contrastRatio, createCanvasSurface, createCanvasTextStyle, createElement, createEnvironmentKey, createPaintState, createTextCache, createTween, createWebGPUSurface, cubicBezier, darkColors, darkTheme, decorated, decorationColor, decorationRect, defaultMotion, defaultShadows, defaultShapes, defaultSpacing, defaultTextStyle, defaultTypography, defaultVisualState, defineModifier, defineProperty, defineThemeExtension, demuxMp4Video, densityFactors, describeLength, describeOverrides, detectEditingPlatform, diffSemantics, dragSessionFor, dragSource, draggable, drawOverlayShapes, drawText, dropTarget, easings, editorFor, editorOf, fade, fillTextRects, findEnvironmentKey, findMatchesIn, findPropertyDefinition, flattenTextSpans, focusRing, fontStackFor, formatConstraints, formatExplanation, formatShortcut, fr, getPropertyNames, glyphCount, gradientPaint, gradientsEqual, graphemeBoundaries, hasDecorationPhase, hasDrawnText, hasTextLinks, hasThemeExtension, hasVisualState, highContrastColors, hoverable, iconKey, iconSource, imageSource, inheritedPropertyFlags, inheritedPropertyNames, initializeWebGPU, inputsEqual, insetPadding, insetsEqual, interactive, interpolateColor, interpolateNumber, interpolateTransform, interpolatorFor, isAutoLength, isComponentLikeElement, isEditableNode, isFrLength, isLayoutProtocol, isMinMaxTrack, isMotionRest, isMultiline, isNodeFocusable, isNodeHitTestable, isNodeInert, isNodeSelectable, isObservable, isPaintVisible, isPercentLength, isPrintable, isReadOnly, isScrollContainer, isShapeName, isTypographyRole, isUiChild, isUiElement, isUiModifier, isUiRole, isUiSemanticState, isVideoSurface, isWebGPUAvailable, labelNode, labelOrigin, layoutParagraph, layoutTextLines, lazySource, lightColors, lightTheme, lineEndAt, lineIndexAtY, lineIndexForOffset, lineLimit, lineStartAt, linear, linearGradient, linkHoverOf, linkOf, linkRunAtPointIn, markInstant, markNow, matchRangesOf, measure, measureSpan, minmax, motion, nextCaretToggle, nextGraphemeEnd, nextWordEnd, noInsets, noKeyModifiers, noModifiers, noThemeExtensions, normalizeBorderRadius, normalizeColor, normalizeStates, normalizeTextAlign, normalizeTransition, normalizeVerticalAlign, observeViewportInsets, offsetAtPoint, offsetAtPointIn, offsetAtX, offsetForVerticalMove, overrideSources, paintPictures, paintValuesEqual, paintsAfterChildren, paragraphGeometry, paragraphGeometryFrom, parseAlignContent, parseColor, parseCrossAxisAlignment, parseFlexDirection, parseMainAxisAlignment, parseShortcut, parseTransform, pathValuesEqual, percent, performanceMarksEnabled, pinchable, placeGridItems, pointerDeviceOf, pop, prepareInputSurface, pressable, previousGraphemeStart, previousWordStart, propertyEffects, propertyIsInherited, propertyValuesEqual, propertyValuesEqualByName, proportionalFontMetrics, provideEnvironment, publishInset, radialGradient, raiseContrast, readMp3Header, recordsEqual, registerFontStack, relativeLuminance, reorderable, repeat, replayPaint, resetOverrideWarnings, resetTransitionWarnings, resolveBoolean, resolveCursor, resolveLength, resolveMotionState, resolveNumber, resolvePaintState, resolveProperty, resolvePropertyByName, resolveString, resolvedSpansOf, rgb8, rgba, rotateFrom, runCanvasStyleInto, runFontString, sameArgs, scaleFrom, scaleSpacing, scrollPosition, scrollbarThumb, scrollbarThumbs, scrollbarZoneAt, selectableTextNodes, selectableTextOf, selectionRangeOf, selectionRects, selectionRectsIn, setLinkHover, setMatchRanges, setPerformanceMarks, setSelectionRange, shadowsEqual, shapesEqual, sharedElement, shortcut, shortcuts, sizeContainer, sizeGridTracks, slideDown, slideFrom, slideUp, spacingEqual, spacingSteps, spanAtOffset, spannedRunsFor, spannedTextOf, splitMp3Frames, spring, statesEqual, steps, syncEditorValue, textContentOf, textRunBackgrounds, textRunDecorations, textRunOfRecordId, textRuns, textSpansEqual, textStylesEqual, themeExtension, themeExtensionsEqual, themeTokens, themesEqual, tightenConstraints, touchActionFor, tracePathData, traceRoundedRect, transform, transformIsIdentity, transformsEqual, tween, typographyEqual, uniformBorderRadius, unknownContainerSize, validateGradient, validateRole, validateStates, validateSubgrid, videoFrameSize, videoSource, visualState, visualStatesEqual, wheelDeltaYOf, withContrast, withDensity, withOverrideSource, withThemeExtension, wordRangeAt, wordRangeIn, writeDeclaredProperty, writeOverrideProperty };
+export { AlignContent, AnimationDriver, BUTTON_INTERACTION, Box, Button, CARET_BLINK_MS, CARET_WIDTH, CLIP_STRIDE_BYTES, CLIP_STRIDE_FLOATS, Canvas2DRenderer, CanvasPlatformSurface, CanvasSurface, CanvasTextMeasurer, CharacterCountTextMeasurer, Column, CommandKind, Constraints, CrossAxisAlignment, DEFAULT_BLOCK_SIZE, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_WEIGHT, DEFAULT_LINE_HEIGHT_FACTOR, DEFAULT_TEXT_COLOR, DefaultImageResolver, DefaultVideoResolver, DirtyFlags, DirtyNodeSet, EDITOR_PROP, ELLIPSIS, EMPTY_RECORDING, EXTERNAL_FILES, EditableLayout, EditableText, EditableTextModel, EnvironmentNotifier, FlexDirection, FocusNotifier, GLYPH_SUBPIXEL_PHASES, GlyphShaper, Grid, INSPECTOR_HEAT_MS, INSTANCE_STRIDE_BYTES, INSTANCE_STRIDE_FLOATS, IconRasterizer, LABEL_PADDING_X, LayoutEngine, LayoutInspector, LayoutNotifier, LayoutRecord, LazyColumn, LazyGrid, LazyRow, MARK_PREFIX, MAX_GRADIENT_STOPS, MAX_MEASURES_PER_CHILD, MOTION_CHANNELS, MOTION_REST, MOUSE_POINTER, MainAxisAlignment, Mp3Frames, NO_CLIP_INDEX, NodeTransitions, Paint, PaintPictureCache, PaintRecorder, PaintTarget, ParagraphTextMeasurer, PrimitiveKind, Responsive, Row, SCROLLBAR_FADE_MS, SCROLLBAR_HOVER_ZONE, SCROLLBAR_INSET, SCROLLBAR_LINGER_MS, SCROLLBAR_MIN_THUMB, SCROLLBAR_THICKNESS, ScrollView, Stack, TEXTURED_STRIDE_BYTES, TEXTURED_STRIDE_FLOATS, TEXT_MATCHES_PROP, TEXT_RUN_ID_SEPARATOR, TEXT_SELECTION_PROP, Text, UI_ROLES, UI_SEMANTIC_STATES, UI_SUBGRID_AXES, UiAnimation, UiAnimationFrameClock, UiBasicColors, UiBeforeInputEvent, UiBinding, UiBorderRadiuses, UiChildrenBinding, UiContainerSizeSource, UiDragSession, UiEditingController, UiEnvironment, UiEnvironmentKeys, UiEventBinding, UiEventType, UiFindController, UiFocusEvent, UiFocusManager, UiFrame, UiGestureEvent, UiGestureRecognizer, UiGraph, UiGraphBuilder, UiHitTester, UiHostFrameClock, UiInputDispatcher, UiInputEvent, UiInsetRegistry, UiKeyboardController, UiKeyboardEvent, UiManualFrameClock, UiModifierSet, UiNode, UiNodeType, UiPinchEvent, UiPinchRecognizer, UiPlatformAdapter, UiPointerController, UiPointerEvent, UiProperties, UiScheduler, UiSelectionController, UiSharedElements, UiShortcutRegistry, UiSpring, UiTextChangeEvent, UiTimerFrameClock, UiTouchScroller, UiTransforms, UiTween, UiUnknownModifierPropertyError, UiVirtualWindow, UiVisualState, UiWheelController, UiWheelDeltaMode, UiWheelEvent, VIRTUAL_INDEX_PROP, VIRTUAL_LEAD_PROP, VIRTUAL_WINDOW_PROP, WebGPUError, WebGPUGlyphAtlas, WebGPUGlyphPages, WebGPURenderer, WebGPUSurface, WebGPUTextureCache, accumulatedOffsetTo, animateLayout, applyCanvasTextStyle, assertModifierList, assertTransitionMap, auto, autoFocus, bandOf, borderRadius, borderRadiusCorners, borderRadiusEqual, borderRadiusIsZero, borderRadiusValuesEqual, boxShadow, boxShadowArraysEqual, boxShadowsEqual, breakpoint, bufferSource, buildFontString, buildRenderList, buildSemanticsSubtree, buildSemanticsTree, bumpFontStack, bundle, canDecodeVideo, capturePointer, caretRectFor, caretVisibleAt, clampSize, clearFontStacks, clearLinkHover, clearMatchRanges, clearOverrideProperty, clearSelectionRange, clickOutside, closestPropertyName, colorToCss, colorToHex, colorToRgba, colorValuesEqual, colorsEqual, colorsEqualPalette, commandForKey, computeObjectFitRect, constraintsEqual, containerBands, contentOffset, contextMenu, contrastRatio, createCanvasSurface, createCanvasTextStyle, createElement, createEnvironmentKey, createPaintState, createTextCache, createTween, createWebGPUSurface, cubicBezier, cueAt, darkColors, darkTheme, decorated, decorationColor, decorationRect, defaultMotion, defaultShadows, defaultShapes, defaultSpacing, defaultTextStyle, defaultTypography, defaultVisualState, defineModifier, defineProperty, defineThemeExtension, demuxMp4Audio, demuxMp4Video, densityFactors, describeLength, describeOverrides, detectEditingPlatform, diffSemantics, dragSessionFor, dragSource, draggable, drawOverlayShapes, drawText, dropTarget, easings, editorFor, editorOf, fade, fillTextRects, findEnvironmentKey, findMatchesIn, findPropertyDefinition, flattenTextSpans, focusRing, fontStackFor, formatConstraints, formatExplanation, formatShortcut, fr, getPropertyNames, glyphCount, gradientPaint, gradientsEqual, graphemeBoundaries, hasDecorationPhase, hasDrawnText, hasTextLinks, hasThemeExtension, hasVisualState, highContrastColors, hoverable, iconKey, iconSource, imageSource, inheritedPropertyFlags, inheritedPropertyNames, initializeWebGPU, inputsEqual, insetPadding, insetsEqual, interactive, interpolateColor, interpolateNumber, interpolateTransform, interpolatorFor, isAutoLength, isComponentLikeElement, isEditableNode, isFrLength, isLayoutProtocol, isMinMaxTrack, isMotionRest, isMultiline, isNodeFocusable, isNodeHitTestable, isNodeInert, isNodeSelectable, isObservable, isPaintVisible, isPercentLength, isPrintable, isReadOnly, isScrollContainer, isShapeName, isTypographyRole, isUiChild, isUiElement, isUiModifier, isUiRole, isUiSemanticState, isVideoSurface, isWebGPUAvailable, labelNode, labelOrigin, layoutParagraph, layoutTextLines, lazySource, lightColors, lightTheme, lineEndAt, lineIndexAtY, lineIndexForOffset, lineLimit, lineStartAt, linear, linearGradient, linkHoverOf, linkOf, linkRunAtPointIn, markInstant, markNow, matchRangesOf, measure, measureSpan, minmax, motion, nextCaretToggle, nextGraphemeEnd, nextWordEnd, noInsets, noKeyModifiers, noModifiers, noThemeExtensions, normalizeBorderRadius, normalizeColor, normalizeStates, normalizeTextAlign, normalizeTransition, normalizeVerticalAlign, observeViewportInsets, offsetAtPoint, offsetAtPointIn, offsetAtX, offsetForVerticalMove, overrideSources, paintPictures, paintValuesEqual, paintsAfterChildren, paragraphGeometry, paragraphGeometryFrom, parseAlignContent, parseColor, parseCrossAxisAlignment, parseFlexDirection, parseMainAxisAlignment, parseShortcut, parseTransform, parseWebVtt, pathValuesEqual, percent, performanceMarksEnabled, pinchable, placeGridItems, pointerDeviceOf, pop, prepareInputSurface, pressable, previousGraphemeStart, previousWordStart, propertyEffects, propertyIsInherited, propertyValuesEqual, propertyValuesEqualByName, proportionalFontMetrics, provideEnvironment, publishInset, radialGradient, raiseContrast, rangeSource, readMp3Header, recordsEqual, registerFontStack, relativeLuminance, reorderable, repeat, replayPaint, resetOverrideWarnings, resetTransitionWarnings, resolveBoolean, resolveCursor, resolveLength, resolveMotionState, resolveNumber, resolvePaintState, resolveProperty, resolvePropertyByName, resolveString, resolvedSpansOf, rgb8, rgba, rotateFrom, runCanvasStyleInto, runFontString, sameArgs, scaleFrom, scaleSpacing, scrollPosition, scrollbarThumb, scrollbarThumbs, scrollbarZoneAt, selectableTextNodes, selectableTextOf, selectionRangeOf, selectionRects, selectionRectsIn, semanticsInertAbove, setLinkHover, setMatchRanges, setPerformanceMarks, setSelectionRange, shadowsEqual, shapesEqual, sharedElement, shortcut, shortcuts, sizeContainer, sizeGridTracks, slideDown, slideFrom, slideUp, spacingEqual, spacingSteps, spanAtOffset, spannedRunsFor, spannedTextOf, splitMp3Frames, spring, statesEqual, steps, syncEditorValue, textContentOf, textRunBackgrounds, textRunDecorations, textRunOfRecordId, textRuns, textSpansEqual, textStylesEqual, themeExtension, themeExtensionsEqual, themeTokens, themesEqual, tightenConstraints, touchActionFor, tracePathData, traceRoundedRect, transform, transformIsIdentity, transformsEqual, tween, typographyEqual, uniformBorderRadius, unknownContainerSize, validateGradient, validateRole, validateStates, validateSubgrid, videoFrameSize, videoSource, visualState, visualStatesEqual, wheelDeltaYOf, withContrast, withDensity, withOverrideSource, withThemeExtension, wordRangeAt, wordRangeIn, writeDeclaredProperty, writeOverrideProperty };
 
 //# sourceMappingURL=index.js.map