@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/run-FzaqmBEl.js

@@ -0,0 +1,3959 @@
+import "./chunk-Rp0pCe6z.js";
+import { $ as flushKeyframeResolvers, Ft as easingDefinitionToFunction, Nt as time, _t as generateLinearEasing, bt as mix, gt as maxGeneratorDuration, ht as calcGeneratorDuration, nn as registerBusyProbe, pt as spring, vt as cancelFrame, yt as frame } from "./layout-group-BS0gklZp.js";
+import { C as animateTarget, c as defineParticipantArg, l as setParticipantHost, w as positionalKeys } from "./node-BWOLCOMI.js";
+import "./src-CbBcj3xm.js";
+import { r as scaleTransition, t as motionSpeed } from "./speed-bIo0tyrM.js";
+//#region ../choreo/src/measure.ts
+/**
+* One measurement layer, for everything that measures.
+*
+* The region and the beacon registry both turn a DOMRect into the three spaces
+* a step can ask for — page, region-relative, offset-parent-relative — and they
+* have to agree exactly, because a Move routinely reads one sprite's `page` and
+* another's. Ember Animated learned the same thing the hard way and ended up
+* with a single bounds module; two copies of `minus` that drift by a scroll
+* offset produce a flight that lands next to its target, which is the kind of
+* bug that looks like a spring problem for a day.
+*/
+defineParticipantArg("pack", (el, pack) => {
+	if (pack === "content") el.setAttribute("data-choreo-pack", "content");
+	else el.removeAttribute("data-choreo-pack");
+});
+/** a box in page space */
+var rect = (r) => ({
+	height: r.height,
+	width: r.width,
+	x: r.left,
+	y: r.top
+});
+/** `a` expressed relative to `b`'s top-left, keeping a's size */
+var minus = (a, b) => ({
+	height: a.height,
+	width: a.width,
+	x: a.left - b.left,
+	y: a.top - b.top
+});
+/** an element's box together with the box it is positioned inside */
+/**
+* The shrink-wrap of `el`'s contents — the ink — not the stretched layout
+* box. A full-bleed title (`left:0; right:0; width:auto`) still has a
+* word-sized range; Crossing crop must match THAT, or the type explodes
+* into a viewport strip. Empty / collapsed → undefined, so the frame wins.
+*/
+var inkBox = (el) => {
+	const doc = el.ownerDocument;
+	if (!doc) return;
+	const range = doc.createRange();
+	range.selectNodeContents(el);
+	const r = range.getBoundingClientRect();
+	if (r.width < .5 && r.height < .5) return;
+	return r;
+};
+var substanceOf = (el) => {
+	const marked = el.querySelector("[data-choreo-substance]")?.getBoundingClientRect();
+	if (marked) return marked;
+	if (el.getAttribute("data-choreo-pack") === "content") return inkBox(el);
+};
+/** the containing block a `position: absolute` child would be placed against */
+var offsetBox = (el) => (el.offsetParent ?? el.parentElement ?? el).getBoundingClientRect();
+/**
+* Does the element have a layout box? One under `display: none` (its own or
+* an ancestor's, as with the `hidden` attribute) measures as an empty rect at
+* the page origin, which is no place to move from or to.
+*/
+var isRendered = (el) => el.getClientRects().length > 0;
+/** `undefined` for an element with no layout box (see `isRendered`) */
+var measure = (el) => isRendered(el) ? snapshotOf(el) : void 0;
+var snapshotOf = (el) => ({
+	el: el.getBoundingClientRect(),
+	paint: getComputedStyle(el).backgroundColor,
+	parent: offsetBox(el),
+	substance: substanceOf(el)
+});
+/** the three spaces, from a snapshot and the region's own box */
+var boundsOf = (snap, root) => ({
+	context: minus(snap.el, root),
+	page: rect(snap.el),
+	paint: snap.paint,
+	parent: minus(snap.el, snap.parent),
+	substance: snap.substance && rect(snap.substance)
+});
+/** measure an element straight into bounds — what a beacon needs */
+var measureBounds = (el, root) => {
+	const snap = measure(el);
+	return snap && boundsOf(snap, root);
+};
+//#endregion
+//#region ../choreo/src/beacons.ts
+/**
+* Beacons — a named box that does not animate.
+*
+* Ember Animated's primitive: `<AnimatedBeacon>` measures its child when a
+* transition starts, stores a sprite on the motion service, and a generator
+* reads `context.beacons` to say "start here" or "end there". The beacon
+* itself never moves.
+*
+*   <button {{beacon 'trash'}}>Trash</button>
+*
+*   <Choreo as |c|>
+*     …
+*     <c.Move @of={{c.removed 'row'}} @to={{c.beacon 'trash'}} />
+*   </Choreo>
+*
+* This is deliberately NOT `layoutId`. `layoutId` pairs two real elements that
+* share an identity and morphs one into the other — putting it on a leaving row
+* and on the bin would make the bin a shared element, and it would stretch. A
+* beacon has no identity in the changeset: it is not inserted, kept or removed,
+* it is a point other sprites may borrow. A beacon moving on its own never
+* starts a run.
+*
+* The registry is document-global on purpose. The case that wants beacons is an
+* inbox — the trash lives in the chrome, the list lives in the outlet, and they
+* are different regions precisely so their changesets stay apart. A region-local
+* registry could not see across that boundary, which is the whole point.
+* packages/choreo-gallery/realm/docs/nested-choreo.md has the reasoning.
+*/
+/** name → the element claiming it. First registration this pass wins, as Ember Animated's `hasBeacon` does. */
+var registry = /* @__PURE__ */ new Map();
+function registerBeacon(name, element) {
+	if (!registry.has(name)) registry.set(name, element);
+	return () => {
+		if (registry.get(name) === element) registry.delete(name);
+	};
+}
+/**
+* Measure the live beacons, in the same window the region measures `final`.
+*
+* Re-measured every pass, never cached: the trash can move without the list
+* rendering at all — a header that hides, a column that resizes, a scroll.
+*
+* A region passes the names its score asked for, so a pass measures only
+* those: a page can claim hundreds of beacons (every chip a sheet may open
+* from), and each region measuring every one on every pass would cost a
+* layout read per beacon per region. Without `names`, every claimed beacon
+* is measured.
+*/
+function measureBeacons(root, names) {
+	const out = /* @__PURE__ */ new Map();
+	const wanted = names ? [...names].map((name) => [name, registry.get(name)]) : [...registry];
+	for (const [name, el] of wanted) {
+		if (!el?.isConnected) continue;
+		const bounds = measureBounds(el, root);
+		if (bounds) out.set(name, bounds);
+	}
+	return out;
+}
+/**
+* Forget every claimed name. The registry outlives any one owner, so a test
+* that tore down mid-flight would otherwise leave a dead element holding a
+* name the next test wants — first-wins turns into first-test-wins.
+* `setupChoreo(hooks)` runs this before and after every test; nothing in an
+* app should.
+*/
+function resetBeacons() {
+	registry.clear();
+}
+//#endregion
+//#region ../choreo/src/gesture.ts
+/**
+* `c.gesture` — the live drag as a first-class geometry source (§6.1, §6.4).
+*
+* A document-level pointer tracker (listeners, not timers) keeps the last
+* pointer position and a short velocity window. A Move that borrows
+* `{{c.gesture}}` as its `@from` starts from wherever the finger let go —
+* sized as the sprite, centred on the pointer — and any spring that flies
+* it inherits the pointer's velocity, so a toss leaves at the speed it was
+* thrown.
+*/
+var GESTURE = { gesture: true };
+function isGestureRef(v) {
+	return typeof v === "object" && v !== null && v.gesture === true;
+}
+var samples = [];
+var tracking = false;
+function record(event) {
+	const now = performance.now();
+	samples.push({
+		t: now,
+		x: event.clientX,
+		y: event.clientY
+	});
+	if (samples.length > 8) samples.shift();
+}
+/** idempotent; the first <Choreo> turns it on */
+function trackGestures() {
+	if (tracking || typeof window === "undefined") return;
+	tracking = true;
+	window.addEventListener("pointerdown", record, {
+		capture: true,
+		passive: true
+	});
+	window.addEventListener("pointermove", record, {
+		capture: true,
+		passive: true
+	});
+	window.addEventListener("pointerup", record, {
+		capture: true,
+		passive: true
+	});
+}
+/** the pointer's page position now, or null before any pointer event */
+function gesturePoint() {
+	const last = samples[samples.length - 1];
+	return last ? {
+		x: last.x,
+		y: last.y
+	} : null;
+}
+/** units per second over the recent window — what a spring inherits */
+function gestureVelocity() {
+	if (samples.length < 2) return {
+		x: 0,
+		y: 0
+	};
+	const now = performance.now();
+	const a = samples.filter((s) => now - s.t < 120)[0] ?? samples[samples.length - 2];
+	const b = samples[samples.length - 1];
+	const dt = (b.t - a.t) / 1e3;
+	if (dt <= 0) return {
+		x: 0,
+		y: 0
+	};
+	return {
+		x: (b.x - a.x) / dt,
+		y: (b.y - a.y) / dt
+	};
+}
+/** the gesture as a box: the sprite\'s own size, centred on the pointer */
+function gestureBounds(size) {
+	const point = gesturePoint();
+	if (!point) return null;
+	const page = {
+		height: size.height,
+		width: size.width,
+		x: point.x - size.width / 2,
+		y: point.y - size.height / 2
+	};
+	return {
+		context: page,
+		page,
+		parent: page
+	};
+}
+/** test-support: forget everything between tests */
+function resetGestures() {
+	samples = [];
+}
+//#endregion
+//#region ../choreo/src/compile.ts
+/**
+* boxel-motion's OrchestrationMatrix, as a cue list: the timeline tree becomes
+* one (sprite, start, duration) per step per sprite. Sequences add, parallels
+* overlay; a spring's length is computed with the engine's own generator so a
+* sequence can follow one — the thing the legacy could not do.
+*/
+var isBlock = (node) => node.kind === "sequence" || node.kind === "parallel";
+var isGate = (node) => node.kind === "gate";
+var DEFAULT_SPRING = {
+	damping: 30,
+	stiffness: 300
+};
+/**
+* What `c.Follow` is allowed to drive: paint, never layout. See the throw
+* in the 'follow' case for why the line is drawn exactly here.
+*/
+var DERIVABLE = new Set([
+	"filter",
+	"opacity",
+	"rotate",
+	"rotateX",
+	"rotateY",
+	"rotateZ",
+	"scale",
+	"scaleX",
+	"scaleY",
+	"skewX",
+	"skewY",
+	"x",
+	"y",
+	"z"
+]);
+/** the shared offstage <svg> that path geometry is sampled inside */
+var pathHost;
+function samplePath(d, samples = 64) {
+	if (!pathHost) {
+		pathHost = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+		pathHost.setAttribute("aria-hidden", "true");
+		pathHost.style.cssText = "position:absolute;width:0;height:0;overflow:hidden";
+		document.body.appendChild(pathHost);
+	}
+	const el = document.createElementNS("http://www.w3.org/2000/svg", "path");
+	el.setAttribute("d", d);
+	pathHost.appendChild(el);
+	try {
+		const length = el.getTotalLength();
+		return Array.from({ length: samples + 1 }, (_, i) => {
+			const pt = el.getPointAtLength(length * i / samples);
+			return {
+				x: pt.x,
+				y: pt.y
+			};
+		});
+	} finally {
+		el.remove();
+	}
+}
+/**
+* Similarity-map a drawn path so its start is the sprite's start and its end
+* is the measured landing (§4.4): the path bends the journey, never the
+* destination. Complex multiplication: m = D / v rotates and scales the
+* author's stroke onto the real displacement.
+*/
+function mapFlight(raw, dx, dy) {
+	const s0 = raw[0];
+	const e = raw[raw.length - 1];
+	const vx = e.x - s0.x;
+	const vy = e.y - s0.y;
+	const mag = vx * vx + vy * vy;
+	if (mag < 1e-6) return raw.map((_, i) => ({
+		x: dx * i / (raw.length - 1),
+		y: dy * i / (raw.length - 1)
+	}));
+	const mr = (dx * vx + dy * vy) / mag;
+	const mi = (dy * vx - dx * vy) / mag;
+	return raw.map((pt) => {
+		const px = pt.x - s0.x;
+		const py = pt.y - s0.y;
+		return {
+			x: px * mr - py * mi,
+			y: px * mi + py * mr
+		};
+	});
+}
+var resolve = (v, sprite, cs) => typeof v === "function" ? v(sprite, cs) : v;
+var single = (v) => Array.isArray(v) ? v[0] : v;
+var num = (v) => {
+	if (typeof v === "number") return v;
+	const n = parseFloat(String(v));
+	return Number.isNaN(n) ? 0 : n;
+};
+/** the value a spring starts from when the step does not say: the engine's, else the computed style's */
+function currentValue(sprite, key) {
+	const ve = sprite.node.visualElement;
+	if (ve?.hasValue(key)) return num(ve.getValue(key).get());
+	const latest = ve?.latestValues?.[key];
+	if (latest !== void 0) return num(latest);
+	return num(getComputedStyle(sprite.element).getPropertyValue(key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase())));
+}
+function springDuration(from, to, spec) {
+	if (from === to) return 0;
+	const generator = spring({
+		keyframes: [from, to],
+		...spec
+	});
+	return Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+}
+/** a cue before it is placed on the run's clock; `offset` is its rung of the stagger ladder */
+/**
+* The rung each index takes on the stagger ladder, under a delivery order.
+* 'center' delivers from the middle outward; 'random' shuffles per run —
+* seeded input is the native driver's requirement, not this one's.
+*/
+function ladder(n, order) {
+	const ranks = Array.from({ length: n }, (_, i) => i);
+	switch (order) {
+		case "reverse": return ranks.map((i) => n - 1 - i);
+		case "center": {
+			const mid = (n - 1) / 2;
+			const byDistance = [...ranks].sort((a, b) => Math.abs(a - mid) - Math.abs(b - mid));
+			const out = new Array(n);
+			byDistance.forEach((index, rank) => out[index] = rank);
+			return out;
+		}
+		case "random": {
+			const shuffled = [...ranks];
+			for (let i = n - 1; i > 0; i--) {
+				const j = Math.floor(Math.random() * (i + 1));
+				[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+			}
+			const out = new Array(n);
+			shuffled.forEach((index, rank) => out[index] = rank);
+			return out;
+		}
+		default: return ranks;
+	}
+}
+function resolveTarget(step, sprite, cs) {
+	const target = {};
+	let longest = 0;
+	for (const key in step.props) {
+		const to = resolve(step.props[key], sprite, cs);
+		if (Array.isArray(to)) {
+			if (step.kind === "spring" && to.length > 2) throw new Error(`choreo: a spring animates between two keyframes; \`${key}\` was given ${to.length}`);
+			target[key] = to;
+			if (step.kind === "spring") longest = Math.max(longest, springDuration(num(to[0]), num(to[to.length - 1]), step.spring ?? DEFAULT_SPRING));
+		} else {
+			target[key] = to;
+			if (step.kind === "spring") longest = Math.max(longest, springDuration(currentValue(sprite, key), num(to), step.spring ?? DEFAULT_SPRING));
+		}
+	}
+	return {
+		longest,
+		target
+	};
+}
+/**
+* The two boxes a shape-matched flight aligns: the declared subjects
+* ([data-choreo-substance], or pack="content" ink) when either end has
+* one — Keynote matches OBJECTS, not slide frames — with the undeclared
+* end derived by fraction (content laid out proportionally keeps one
+* fraction at both scales; the return trip's card, whose demo has not
+* boarded yet, has nothing to measure). Neither end declared: the frames
+* themselves.
+*/
+function matchBoxes(initial, final, from, to, z) {
+	const subI = initial.substance && descale(initial.substance, z);
+	const subF = final.substance && descale(final.substance, z);
+	if (!subI && !subF) return {
+		from,
+		to
+	};
+	const map = (s, a, b) => ({
+		height: s.height / (a.height || 1) * b.height,
+		width: s.width / (a.width || 1) * b.width,
+		x: b.x + (s.x - a.x) / (a.width || 1) * b.width,
+		y: b.y + (s.y - a.y) / (a.height || 1) * b.height
+	});
+	return {
+		from: subI ?? map(subF, to, from),
+		to: subF ?? map(subI, from, to)
+	};
+}
+var centreOf = (r) => ({
+	x: r.x + r.width / 2,
+	y: r.y + r.height / 2
+});
+/** a page-space box, divided back into local space by the measure-time zoom */
+function descale(r, z) {
+	return z === 1 ? r : {
+		height: r.height / z,
+		width: r.width / z,
+		x: r.x / z,
+		y: r.y / z
+	};
+}
+function resolveMove(step, sprite, cs) {
+	const size = (sprite.final ?? sprite.initial)?.page ?? {
+		height: 0,
+		width: 0,
+		x: 0,
+		y: 0
+	};
+	const hot = step.from && isGestureRef(step.from);
+	const borrowedFrom = step.from ? hot ? gestureBounds(size) : cs.beacon(step.from.beacon) : null;
+	const borrowedTo = step.to ? cs.beacon(step.to.beacon) : null;
+	const initial = borrowedFrom ?? sprite.initial;
+	const final = borrowedTo ?? sprite.final;
+	if (!initial || !final) return null;
+	const z = cs.measureZoom ?? 1;
+	const parentSpace = step.space === "parent" && !borrowedFrom && !borrowedTo;
+	const from = descale(parentSpace ? initial.parent : initial.page, z);
+	const to = descale(parentSpace ? final.parent : final.page, z);
+	const target = {};
+	const pairs = [];
+	const scaleMode = step.size === "scale" || step.size === "crop";
+	const cropMode = step.size === "crop";
+	const m = scaleMode ? matchBoxes(initial, final, from, to, z) : null;
+	const dx = m ? centreOf(m.to).x - centreOf(m.from).x : to.x - from.x;
+	const dy = m ? cropMode ? m.to.y - m.from.y : centreOf(m.to).y - centreOf(m.from).y : to.y - from.y;
+	/**
+	* Which end the element is actually sitting on decides the sign.
+	*
+	* The usual FLIP case is a kept sprite: the pass has already put it at its
+	* destination, so it is pulled back by the delta and animated to zero. A
+	* REMOVED sprite is the other way round — the region has locked it in the
+	* orphan layer at the place it was, so it starts at zero and travels the
+	* delta. That is the only case that can have a `final` at all, and it only
+	* has one because a beacon lent it one.
+	*/
+	const holdsStart = sprite.type === "removed";
+	const leg = (d) => holdsStart ? [0, d] : [-d, 0];
+	let flight;
+	if (step.path && (dx !== 0 || dy !== 0)) {
+		flight = {
+			points: mapFlight(samplePath(step.path), dx, dy),
+			rest: holdsStart ? {
+				x: 0,
+				y: 0
+			} : {
+				x: dx,
+				y: dy
+			},
+			rotate: step.rotate
+		};
+		pairs.push(leg(Math.hypot(dx, dy)));
+	} else if (m) {
+		const crop = cropMode;
+		const rx = m.from.width / (m.to.width || 1) || 1;
+		const ry = m.from.height / (m.to.height || 1) || 1;
+		const su = rx;
+		const sx = crop ? su : rx;
+		const sy = crop ? su : ry;
+		const fx = holdsStart ? 1 / sx : sx;
+		const fy = holdsStart ? 1 / sy : sy;
+		const anchor = centreOf(holdsStart ? from : to);
+		const matched = holdsStart ? m.from : m.to;
+		const pinned = crop ? {
+			x: centreOf(matched).x,
+			y: matched.y
+		} : centreOf(matched);
+		const cx = (1 - fx) * (pinned.x - anchor.x);
+		const cy = (1 - fy) * (pinned.y - anchor.y);
+		const x = holdsStart ? dx + cx : -dx + cx;
+		const y = holdsStart ? dy + cy : -dy + cy;
+		if (x !== 0) {
+			target["x"] = holdsStart ? [0, x] : [x, 0];
+			pairs.push(holdsStart ? [0, x] : [x, 0]);
+		}
+		if (y !== 0) {
+			target["y"] = holdsStart ? [0, y] : [y, 0];
+			pairs.push(holdsStart ? [0, y] : [y, 0]);
+		}
+		if (crop) {
+			if (fx !== 1) target["scale"] = holdsStart ? [1, fx] : [fx, 1];
+			const frame = holdsStart ? from : to;
+			const window = holdsStart ? m.to : m.from;
+			const f = holdsStart ? fx : sx;
+			const d = {
+				x,
+				y
+			};
+			const pre = (edge) => anchor.y + (edge - anchor.y - d.y) / f;
+			const clamp = (v) => Math.max(0, v);
+			const b = clamp(frame.y + frame.height - pre(window.y + window.height));
+			if (b > .5) {
+				const far = `inset(0px 0px ${b.toFixed(2)}px 0px)`;
+				const rest = "inset(0px 0px 0px 0px)";
+				target["clipPath"] = holdsStart ? [rest, far] : [far, rest];
+			}
+		} else {
+			if (fx !== 1) target["scaleX"] = holdsStart ? [1, fx] : [fx, 1];
+			if (fy !== 1) target["scaleY"] = holdsStart ? [1, fy] : [fy, 1];
+		}
+	} else {
+		if (dx !== 0) {
+			target["x"] = leg(dx);
+			pairs.push(leg(dx));
+		}
+		if (dy !== 0) {
+			target["y"] = leg(dy);
+			pairs.push(leg(dy));
+		}
+	}
+	if (scaleMode) {} else if (step.size !== false) {
+		if (from.width !== to.width) {
+			target["width"] = [from.width, to.width];
+			pairs.push([from.width, to.width]);
+		}
+		if (from.height !== to.height) {
+			target["height"] = [from.height, to.height];
+			pairs.push([from.height, to.height]);
+		}
+	}
+	if (!pairs.length) return null;
+	let longest = step.ms ?? 0;
+	if (step.ms === void 0) {
+		const spec = step.spring ?? DEFAULT_SPRING;
+		for (const [a, b] of pairs) longest = Math.max(longest, springDuration(a, b, spec));
+	}
+	return {
+		flight,
+		longest,
+		target,
+		velocity: hot ? gestureVelocity() : void 0
+	};
+}
+/** parse a computed rgb()/rgba() color into channels, or null */
+function rgbOf(css) {
+	if (!css) return null;
+	const m = /^rgba?\(([\d.]+),\s*([\d.]+),\s*([\d.]+)(?:,\s*([\d.]+))?\)$/.exec(css);
+	if (!m) return null;
+	return {
+		a: m[4] === void 0 ? 1 : parseFloat(m[4]),
+		b: parseFloat(m[3]),
+		g: parseFloat(m[2]),
+		r: parseFloat(m[1])
+	};
+}
+/**
+* A skin's EFFECTIVE color: its background alpha-blended against the ground
+* it stood on — opacity turned into an actual color (§4.7). Null when the
+* skin has no visible background (type over transparency crossfades as
+* opacity, there is nothing to solidify) or wears a color this parser does
+* not speak, in which case the crossfade stays a plain dissolve.
+*/
+function effective(paint, ground) {
+	const src = rgbOf(paint);
+	if (!src || src.a === 0) return null;
+	if (src.a === 1) return `rgb(${src.r}, ${src.g}, ${src.b})`;
+	const dst = rgbOf(ground);
+	if (!dst) return null;
+	const mix = (s, d) => Math.round(s * src.a + d * (1 - src.a));
+	return `rgb(${mix(src.r, dst.r)}, ${mix(src.g, dst.g)}, ${mix(src.b, dst.b)})`;
+}
+var tweenTransition = (step, ms) => ({
+	duration: ms / 1e3,
+	ease: step.ease ?? "easeInOut",
+	type: "tween",
+	..."times" in step && step.times ? { times: step.times } : {}
+});
+var springTransition = (spec) => ({
+	...spec ?? DEFAULT_SPRING,
+	type: "spring"
+});
+function resolveStep(step, cs, exclude) {
+	const sprites = cs.sprites(step.of ?? {}).filter((s) => !exclude || !exclude.has(s));
+	const delay = step.delay ?? 0;
+	const cues = [];
+	const stagger = step.stagger ?? 0;
+	/** text delivery: the sprite is split and the ladder happens INSIDE the
+	*  step's span, so the sprites themselves are not laddered */
+	const splitting = (step.kind === "tween" || step.kind === "spring") && step.by !== void 0 && step.by !== "item";
+	const order = step.kind === "tween" || step.kind === "spring" ? step.order ?? "forward" : "forward";
+	const ranks = splitting ? [] : ladder(sprites.length, order);
+	let longest = 0;
+	let open = false;
+	for (const [index, sprite] of sprites.entries()) {
+		if ((step.kind === "camera" || step.kind === "camera3d" || step.kind === "tether" || step.of === void 0) && index > 0) break;
+		const offset = splitting ? 0 : stagger * (ranks[index] ?? index);
+		switch (step.kind) {
+			case "tween": {
+				const { target } = resolveTarget(step, sprite, cs);
+				if (step.times !== void 0) {
+					const times = step.times;
+					if (times.length < 2 || times[0] !== 0 || times[times.length - 1] !== 1 || times.some((time, i) => !Number.isFinite(time) || time < 0 || time > 1 || i > 0 && time <= times[i - 1]) || Object.values(target).some((value) => Array.isArray(value) && value.length !== times.length)) throw new Error("choreo: Tween times must increase from 0 to 1 and match every keyframe array");
+				}
+				if (Object.keys(target).length) {
+					const loop = step.repeat === Infinity;
+					const plays = loop ? 1 : 1 + (step.repeat ?? 0);
+					const length = step.ms * plays;
+					const transition = tweenTransition(step, step.ms);
+					if (step.repeat) {
+						transition["repeat"] = step.repeat;
+						transition["repeatType"] = step.repeatType ?? "loop";
+					}
+					cues.push({
+						delivery: splitting ? {
+							by: step.by,
+							order,
+							stagger
+						} : void 0,
+						duration: length,
+						kind: "tween",
+						loop: loop || void 0,
+						offset,
+						sprite,
+						target,
+						transition
+					});
+					longest = Math.max(longest, offset + (loop ? step.ms : length));
+				}
+				break;
+			}
+			case "spring": {
+				const { target, longest: d } = resolveTarget(step, sprite, cs);
+				if (Object.keys(target).length) {
+					cues.push({
+						delivery: splitting ? {
+							by: step.by,
+							order,
+							stagger
+						} : void 0,
+						duration: d,
+						kind: "spring",
+						offset,
+						sprite,
+						target,
+						transition: springTransition(step.spring)
+					});
+					longest = Math.max(longest, offset + d);
+				}
+				break;
+			}
+			case "move": {
+				const r = resolveMove(step, sprite, cs);
+				if (r) {
+					const transition = step.ms === void 0 ? springTransition(step.spring) : tweenTransition(step, step.ms);
+					if (r.velocity && step.ms === void 0) {
+						if (r.target["x"]) transition["x"] = {
+							...transition,
+							velocity: r.velocity.x
+						};
+						if (r.target["y"]) transition["y"] = {
+							...transition,
+							velocity: r.velocity.y
+						};
+					}
+					cues.push({
+						duration: r.longest,
+						flight: r.flight,
+						kind: "move",
+						offset,
+						sprite,
+						target: r.target,
+						transition
+					});
+					longest = Math.max(longest, offset + r.longest);
+					const cp = sprite.counterpart;
+					const swap = step.swap ?? "during";
+					if (cp && !cp.sent && swap !== "none" && sprite.final && cp.initial) {
+						const cpz = cs.measureZoom ?? 1;
+						const from = descale(cp.initial.page, cpz);
+						const to = descale(sprite.final.page, cpz);
+						const cpTarget = {};
+						if (step.size === "scale" || step.size === "crop") {
+							const crop = step.size === "crop";
+							const cpm = matchBoxes(cp.initial, sprite.final, from, to, cpz);
+							const mf = centreOf(cpm.from);
+							const mt = centreOf(cpm.to);
+							const anchor = centreOf(from);
+							const rx = cpm.to.width / (cpm.from.width || 1) || 1;
+							const ry = cpm.to.height / (cpm.from.height || 1) || 1;
+							const eu = rx;
+							const ex = crop ? eu : rx;
+							const ey = crop ? eu : ry;
+							const dxe = mt.x - anchor.x - ex * (mf.x - anchor.x);
+							const dye = crop ? cpm.to.y - anchor.y - ey * (cpm.from.y - anchor.y) : mt.y - anchor.y - ey * (mf.y - anchor.y);
+							if (dxe !== 0) cpTarget["x"] = [0, dxe];
+							if (dye !== 0) cpTarget["y"] = [0, dye];
+							if (crop) {
+								if (ex !== 1) cpTarget["scale"] = [1, ex];
+								const pre = (edge) => anchor.y + (edge - anchor.y - dye) / ex;
+								const clamp = (v) => Math.max(0, v);
+								const cb = clamp(from.y + from.height - pre(cpm.to.y + cpm.to.height));
+								if (cb > .5) cpTarget["clipPath"] = ["inset(0px 0px 0px 0px)", `inset(0px 0px ${cb.toFixed(2)}px 0px)`];
+							} else {
+								if (ex !== 1) cpTarget["scaleX"] = [1, ex];
+								if (ey !== 1) cpTarget["scaleY"] = [1, ey];
+							}
+						} else {
+							if (to.x !== from.x) cpTarget["x"] = [0, to.x - from.x];
+							if (to.y !== from.y) cpTarget["y"] = [0, to.y - from.y];
+							if (step.size !== false) {
+								if (from.width !== to.width) cpTarget["width"] = [from.width, to.width];
+								if (from.height !== to.height) cpTarget["height"] = [from.height, to.height];
+							}
+						}
+						if (Object.keys(cpTarget).length) cues.push({
+							duration: r.longest,
+							kind: "move",
+							offset,
+							sprite: cp,
+							target: cpTarget,
+							transition
+						});
+						if (swap === "during") {
+							const oldSkin = effective(cp.initial?.paint, cs.ground);
+							const newSkin = effective(sprite.final?.paint, cs.ground);
+							const fade = {
+								duration: r.longest / 1e3,
+								ease: "easeInOut"
+							};
+							if (oldSkin && newSkin) {
+								cues.push({
+									borrow: true,
+									duration: r.longest,
+									kind: "tween",
+									offset,
+									sprite,
+									target: { backgroundColor: [oldSkin, newSkin] },
+									transition: fade
+								});
+								cues.push({
+									duration: r.longest,
+									hold: {
+										fill: false,
+										values: { zIndex: 3 }
+									},
+									kind: "hold",
+									offset,
+									sprite: cp
+								});
+							} else cues.push({
+								duration: r.longest,
+								kind: "tween",
+								offset,
+								sprite,
+								target: { opacity: [0, 1] },
+								transition: fade
+							});
+							cues.push({
+								duration: r.longest,
+								kind: "tween",
+								offset,
+								sprite: cp,
+								target: { opacity: [1, 0] },
+								transition: fade
+							});
+						} else cues.push({
+							duration: r.longest,
+							hold: {
+								fill: false,
+								values: { opacity: 0 }
+							},
+							kind: "hold",
+							offset,
+							sprite
+						});
+					}
+				}
+				break;
+			}
+			case "hold": {
+				const values = {};
+				for (const key in step.props) values[key] = single(resolve(step.props[key], sprite, cs));
+				cues.push({
+					duration: step.ms ?? 0,
+					hold: {
+						fill: step.fill ?? false,
+						values
+					},
+					kind: "hold",
+					offset,
+					sprite
+				});
+				if (step.ms === void 0) open = true;
+				else longest = Math.max(longest, offset + step.ms);
+				break;
+			}
+			case "camera": {
+				const ms = step.ms ?? 600;
+				const fitting = step.fit !== void 0;
+				const aiming = step.aim !== void 0;
+				const aimQuery = fitting ? step.fit : step.aim ?? step.origin;
+				const originSprite = aimQuery ? cs.sprite(aimQuery) : null;
+				const box = originSprite?.final?.context ?? originSprite?.initial?.context;
+				const oz = cs.measureZoom ?? 1;
+				const origin = box ? {
+					x: (box.x + box.width / 2) / oz,
+					y: (box.y + box.height / 2) / oz
+				} : void 0;
+				let to = {
+					x: step.x,
+					y: step.y,
+					zoom: step.zoom
+				};
+				const by = step.panBy || step.zoomBy !== void 0 ? {
+					x: step.panBy?.x,
+					y: step.panBy?.y,
+					zoom: step.zoomBy
+				} : void 0;
+				if (aiming && !fitting) to = box && origin && cs.frame ? {
+					x: cs.frame.width / 2 - origin.x,
+					y: cs.frame.height / 2 - origin.y,
+					zoom: void 0
+				} : {
+					x: 0,
+					y: 0,
+					zoom: 1
+				};
+				if (fitting) if (box && origin && cs.frame) {
+					const zoom = step.zoom ?? (step.margin ?? .72) * Math.min(cs.frame.width * oz / box.width, cs.frame.height * oz / box.height);
+					to = {
+						x: cs.frame.width / 2 - origin.x,
+						y: cs.frame.height / 2 - origin.y,
+						zoom
+					};
+				} else to = {
+					x: 0,
+					y: 0,
+					zoom: 1
+				};
+				cues.push({
+					camera: {
+						by,
+						centre: cs.frame ? {
+							x: cs.frame.width / 2,
+							y: cs.frame.height / 2
+						} : void 0,
+						origin,
+						steady: step.steady ? cs.sprites(step.steady) : [],
+						to
+					},
+					duration: ms,
+					kind: "camera",
+					offset,
+					sprite,
+					transition: step.spring ? springTransition(step.spring) : {
+						duration: ms / 1e3,
+						ease: step.ease ?? "easeInOut"
+					}
+				});
+				longest = Math.max(longest, offset + ms);
+				break;
+			}
+			case "camera3d": {
+				const ms = step.ms ?? 600;
+				cues.push({
+					camera3d: {
+						by: step.by,
+						settle: step.settle,
+						tension: step.tension,
+						through: step.through,
+						to: {
+							dolly: step.dolly,
+							look: step.look,
+							pitch: step.pitch,
+							x: step.x,
+							y: step.y,
+							yaw: step.yaw
+						}
+					},
+					duration: ms,
+					kind: "camera3d",
+					offset,
+					sprite,
+					transition: step.spring ? springTransition(step.spring) : {
+						duration: ms / 1e3,
+						ease: step.ease ?? "easeInOut"
+					}
+				});
+				longest = Math.max(longest, offset + ms);
+				break;
+			}
+			case "tether":
+				cues.push({
+					duration: step.ms ?? 0,
+					kind: "tether",
+					offset,
+					sprite,
+					tether: {
+						from: cs.sprites(step.from)[0] ?? null,
+						name: step.name,
+						path: step.path,
+						to: cs.sprites(step.to)[0] ?? null
+					}
+				});
+				if (step.ms === void 0) open = true;
+				else longest = Math.max(longest, offset + step.ms);
+				break;
+			case "follow": {
+				for (const key of Object.keys(step.rest)) if (!DERIVABLE.has(key)) throw new Error(`choreo: c.Follow cannot drive '${key}' — a derived value is computed every frame, so it may only write transform, opacity and filter properties, never layout`);
+				const fz = cs.measureZoom ?? 1;
+				const inZ = (r) => ({
+					height: r.height / fz,
+					width: r.width / fz,
+					x: r.x / fz,
+					y: r.y / fz
+				});
+				const restBounds = sprite.final ?? sprite.initial;
+				if (!restBounds) break;
+				const followed = [];
+				for (const source of cs.sprites(step.to)) {
+					const toB = source.final ?? source.initial;
+					const fromB = source.initial ?? source.final;
+					if (toB && fromB) followed.push({
+						from: inZ(fromB.context),
+						sprite: source,
+						to: inZ(toB.context)
+					});
+				}
+				const ms = step.ms;
+				cues.push({
+					derive: {
+						read: step.read,
+						rest: step.rest,
+						restBox: inZ(restBounds.context),
+						sources: followed
+					},
+					duration: ms ?? 0,
+					kind: "follow",
+					offset,
+					sprite
+				});
+				if (ms === void 0) open = true;
+				else longest = Math.max(longest, offset + ms);
+				break;
+			}
+			case "scroll": {
+				const ms = step.ms ?? 420;
+				cues.push({
+					duration: ms,
+					kind: "scroll",
+					offset,
+					scroll: { align: step.align ?? "center" },
+					sprite
+				});
+				longest = Math.max(longest, offset + ms);
+				break;
+			}
+			case "raise":
+				cues.push({
+					duration: step.ms ?? 0,
+					kind: "raise",
+					offset,
+					raise: { shadow: step.shadow ?? false },
+					sprite
+				});
+				if (step.ms === void 0) open = true;
+				else longest = Math.max(longest, offset + step.ms);
+				break;
+			case "attach":
+				cues.push({
+					attach: {
+						end: step.end ?? "hold",
+						exact: step.exact ?? false,
+						in: step.in ?? 0,
+						rate: step.rate ?? 1,
+						region: step.region
+					},
+					duration: step.ms,
+					kind: "attach",
+					offset,
+					sprite
+				});
+				longest = Math.max(longest, offset + step.ms);
+				break;
+			case "wait":
+				cues.push({
+					duration: step.ms,
+					kind: "wait",
+					offset,
+					sprite
+				});
+				longest = Math.max(longest, offset + step.ms);
+				break;
+			case "perform":
+				cues.push({
+					duration: 0,
+					kind: "perform",
+					offset,
+					perform: {
+						action: step.action,
+						payload: step.payload,
+						target: step.target
+					},
+					sprite
+				});
+				longest = Math.max(longest, offset);
+				break;
+		}
+	}
+	return {
+		cues,
+		duration: cues.length ? delay + longest : 0,
+		open
+	};
+}
+function compile(tree, cs) {
+	const explicit = /* @__PURE__ */ new Set();
+	const claim = (node) => {
+		if (isGate(node)) return;
+		if (isBlock(node)) {
+			node.children.forEach(claim);
+			return;
+		}
+		if (node.generic || node.kind !== "tween" && node.kind !== "spring" && node.kind !== "move" && node.kind !== "hold") return;
+		const q = node.of;
+		if (!(Array.isArray(q) ? q.length > 0 : q.id !== void 0 || q.role !== void 0 || q.type !== void 0)) return;
+		for (const s of cs.sprites(q)) explicit.add(s);
+	};
+	tree.forEach(claim);
+	const resolved = /* @__PURE__ */ new Map();
+	const of = (step) => {
+		let r = resolved.get(step);
+		if (!r) {
+			r = resolveStep(step, cs, step.generic ? explicit : void 0);
+			resolved.set(step, r);
+		}
+		return r;
+	};
+	/**
+	* A node's own length, anchoring aside — for a block, the span its
+	* children occupy, which is what a `@name` on it promises to anyone who
+	* anchors against it.
+	*/
+	const extent = (node) => {
+		if (isGate(node)) return 0;
+		if (!isBlock(node)) return of(node).duration;
+		return node.kind === "sequence" ? node.children.reduce((sum, c) => sum + measure(c), 0) : node.children.reduce((max, c) => Math.max(max, measure(c)), 0);
+	};
+	/** what a node contributes to its parent's flow */
+	const measure = (node) => {
+		if (isGate(node)) return 0;
+		if (node.at) return 0;
+		return isBlock(node) ? (node.delay ?? 0) + extent(node) : of(node).duration;
+	};
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const checkNames = (node) => {
+		if (isGate(node)) return;
+		if (node.name) {
+			if (seen.has(node.name)) throw new Error(`choreo: two steps named '${node.name}'`);
+			seen.add(node.name);
+		}
+		if (isBlock(node)) node.children.forEach(checkNames);
+	};
+	tree.forEach(checkNames);
+	/** where each named step landed: when it starts (delay spent) and how long it plays */
+	const names = /* @__PURE__ */ new Map();
+	const gates = [];
+	/**
+	* A pause is a total order (§4.1): a gate may only stand in a sequence
+	* that no parallel contains — including the implicit parallel that is the
+	* region's root when it has more than one top-level node.
+	*/
+	const forbidGates = (node) => {
+		if (isGate(node)) throw new Error("choreo: a gate inside a parallel has no meaning — a pause is a total order; only an uncontained sequence can hold one");
+		if (isBlock(node)) node.children.forEach(forbidGates);
+	};
+	/**
+	* The whole score's span — computed BEFORE anything is placed, because an
+	* open step's window depends on it.
+	*
+	* A score of nothing but open steps measures zero, and an open step's
+	* window is "the enclosing block's span" — so the annotation the author
+	* asked to be simply ON compiled to a zero-length run that ended on the
+	* frame it was born. That is not a short wire, it is no wire; the app
+	* that hit it wrote `ms: 3_600_000` to get an hour of clock out of a
+	* step whose real lifetime is the scene's. So a score with no length of
+	* its own does not borrow zero: its open cues STAND (§4.6), and the run
+	* holds them until it is cancelled or replaced.
+	*/
+	const root = measure({
+		children: tree,
+		kind: "parallel"
+	});
+	const standingScore = root === 0;
+	/** did any cue actually take the standing window? */
+	let stood = false;
+	/** span: the time a hold without @duration is allowed to last from `start` */
+	const place = (node, start, span) => {
+		if (isGate(node)) {
+			gates.push({
+				at: start,
+				auto: node.ms
+			});
+			return;
+		}
+		/** where an anchored node begins — the same arithmetic for a step and a block */
+		const anchored = (ref) => {
+			const target = names.get(ref.anchor);
+			if (!target) throw new Error(`choreo: @at names '${ref.anchor}', which is not a step above this one — anchors point up the score`);
+			return ref.edge === "end" ? target.start + target.duration + (ref.delay ?? 0) * 1e3 : target.start + (ref.progress ?? 0) * target.duration;
+		};
+		if (!isBlock(node)) {
+			const r = of(node);
+			const delay = node.delay ?? 0;
+			let base = start;
+			if (node.at) {
+				if (r.open) throw new Error("choreo: an anchored hold needs its own @duration — lifted out of its block, it has no span to borrow");
+				base = anchored(node.at);
+			}
+			if (node.name) names.set(node.name, {
+				duration: Math.max(0, r.duration - delay),
+				start: base + delay
+			});
+			for (const cue of r.cues) {
+				const { offset, ...rest } = cue;
+				const borrows = r.open && (cue.kind === "hold" || cue.kind === "raise" || cue.kind === "tether" || cue.kind === "follow");
+				if (borrows && standingScore) stood = true;
+				out.push({
+					...rest,
+					duration: borrows ? standingScore ? Infinity : Math.max(0, span - delay - offset) : cue.duration,
+					standing: borrows && standingScore ? true : void 0,
+					start: base + delay + offset
+				});
+			}
+			return;
+		}
+		const total = extent(node);
+		const from = (node.at ? anchored(node.at) : start) + (node.delay ?? 0);
+		if (node.name) names.set(node.name, {
+			duration: total,
+			start: from
+		});
+		if (node.kind === "sequence") {
+			let offset = 0;
+			for (const child of node.children) {
+				place(child, from + offset, total - offset);
+				offset += measure(child);
+			}
+			return;
+		}
+		node.children.forEach(forbidGates);
+		for (const child of node.children) place(child, from, total);
+	};
+	if (tree.length > 1) tree.forEach(forbidGates);
+	for (const node of tree) place(node, 0, root);
+	gates.sort((a, b) => a.at - b.at);
+	const derived = out.filter((cue) => cue.derive);
+	if (!derived.length) return {
+		cues: out,
+		gates,
+		open: stood
+	};
+	const nameOf = (sprite) => sprite.id ?? sprite.role ?? "a sprite";
+	const drivenBy = /* @__PURE__ */ new Map();
+	for (const cue of derived) drivenBy.set(cue.sprite, cue);
+	for (const cue of derived) for (const source of cue.derive.sources) if (drivenBy.has(source.sprite)) throw new Error(`choreo: c.Follow on '${nameOf(cue.sprite)}' reads '${nameOf(source.sprite)}', which is itself derived — a follower may not follow a follower`);
+	return {
+		cues: [...out.filter((cue) => !cue.derive), ...derived],
+		gates,
+		open: stood
+	};
+}
+/**
+* A replacement pass's continuity cue (§3.1): the prior run was driving
+* this sprite through space and the new score does not name it. Unnamed
+* it would be released to its rest in one frame — the whole-bay snap —
+* so the region completes the score: one shape-matched move from the
+* painted box (which is what a mid-flight sprite's `initial` IS, by
+* design) to its rest. Transform-only, so a continuation can never
+* reflow the scene it is tidying; on the interrupted cue's own spring
+* when it had one, so the carry-on keeps the flight's character.
+*/
+function continuation(sprite, cs, inherited) {
+	const r = resolveMove({
+		kind: "move",
+		of: {},
+		size: "scale"
+	}, sprite, cs);
+	if (!r) return null;
+	const springy = inherited && (inherited["type"] === "spring" || "stiffness" in inherited || "visualDuration" in inherited || "bounce" in inherited);
+	return {
+		duration: r.longest,
+		flight: r.flight,
+		kind: "move",
+		sprite,
+		start: 0,
+		target: r.target,
+		transition: springy ? inherited : springTransition(void 0)
+	};
+}
+/**
+* A replacement pass's continuity cue for a cut-short tween (§3.1): the
+* prior run was taking these values (an opacity, mostly) somewhere and the
+* new score does not. Stopped where they stood they would stay there for
+* good — a fade-in frozen at a few percent — so the region carries each on
+* from its painted value to where it was going, over the time it had left,
+* after the delay it had left (a staggered arrival that had not begun).
+*/
+function fadeOn(sprite, to, remaining, delay = 0) {
+	return {
+		duration: remaining,
+		kind: "tween",
+		sprite,
+		start: delay,
+		target: { ...to },
+		transition: {
+			duration: remaining / 1e3,
+			ease: "easeOut"
+		}
+	};
+}
+/**
+* Whether two compiled scores are the SAME statement — used by the region
+* to keep an in-flight run when an unrelated render replays the pass (the
+* render detector is volatile by design, so on a busy page every region
+* re-passes on every app render; a neighbouring demo writing tracked state
+* per frame must not restart this region's clock).
+*
+* The comparison is deliberately conservative. A FLIGHT is measured off the
+* page and is not comparable by value: any cue carrying one makes the scores
+* different, and the pass replays exactly as it always did. Values that ARE
+* comparable (targets, transitions, delivery plans, holds, camera aims)
+* compare structurally, so an edit that retimes or re-aims anything replays.
+*
+* Tethers, raises and scrolls used to be lumped in with flights, and that was
+* wrong in a way that only showed up on standing annotations: a wire that is
+* simply ON was recompiled to the identical statement on every pass and, being
+* declared different every time, had its run torn down and rebuilt — the path
+* element removed from the layer and a new one appended, sixty times a second
+* on a busy page. None of the three carries measured geometry in its cue: a
+* tether is two sprites and a function, a raise is a sprite and a flag, a
+* scroll is a sprite and an alignment. They compare by IDENTITY, which is
+* exactly what "the same statement" means for them — and it matters most for
+* the scroll, where replacing the cue is a visible restart of the scroll.
+*/
+function sameScore(a, b) {
+	return a.length === b.length && a.every((cue, i) => sameCue(cue, b[i]));
+}
+function sameCue(a, b) {
+	if (a.kind !== b.kind || a.sprite.node !== b.sprite.node || a.start !== b.start || a.duration !== b.duration || (a.loop ?? false) !== (b.loop ?? false)) return false;
+	if (a.flight || b.flight) return false;
+	if (a.tether || b.tether) {
+		if (!a.tether || !b.tether || a.tether.from?.node !== b.tether.from?.node || a.tether.to?.node !== b.tether.to?.node || a.tether.path !== b.tether.path || a.tether.name !== b.tether.name) return false;
+	}
+	if (a.raise || b.raise) {
+		if (!a.raise || !b.raise || a.raise.shadow !== b.raise.shadow) return false;
+	}
+	if (a.attach || b.attach) {
+		if (!a.attach || !b.attach || a.attach.region !== b.attach.region || a.attach.in !== b.attach.in || a.attach.rate !== b.attach.rate || a.attach.end !== b.attach.end) return false;
+	}
+	if (a.scroll || b.scroll) {
+		if (!a.scroll || !b.scroll || a.scroll.align !== b.scroll.align) return false;
+	}
+	const plain = (v) => JSON.stringify(v ?? null);
+	const cam = (c) => c ? {
+		centre: c.centre ?? null,
+		origin: c.origin ?? null,
+		steady: c.steady.length,
+		to: c.to
+	} : null;
+	return plain(a.target) === plain(b.target) && plain(a.transition) === plain(b.transition) && plain(a.delivery) === plain(b.delivery) && plain(a.hold) === plain(b.hold) && plain(cam(a.camera)) === plain(cam(b.camera)) && plain(a.camera3d) === plain(b.camera3d);
+}
+//#endregion
+//#region ../choreo/src/far.ts
+/**
+* Far matching — one identity, two regions.
+*
+* A `<Choreo>` is a scene: it reconciles its own participants and nothing else.
+* That is the point of nesting, and it is why an element that leaves one region
+* and appears in another looks like a death and an unrelated birth rather than
+* one continuous flight.
+*
+* Ember Animated calls the two halves `sentSprites` and `receivedSprites` and
+* pairs them at a `farMatch` rendezvous — every animator that is starting this
+* pass parks, they all wake together, and each reads the others' lists. The
+* legacy boxel-motion described this but never built it.
+*
+* The rendezvous here is a barrier in the render pass itself, not a timed one.
+* Every region that will animate this pass announces itself while Glimmer is
+* still rendering (`join`), the first announcement books one post-render
+* callback for all of them, and that callback runs three phases in order:
+*
+*   1. MEASURE — every region builds its changeset. Nobody has run anything,
+*      so nobody's in-flight values are polluting anybody else's measurement.
+*   2. MATCH   — inserted ids are paired against removed ids in OTHER regions.
+*   3. RUN     — every region compiles and plays its own timeline.
+*
+* All three are synchronous, so no frame is painted between a region measuring
+* and a region pinning its start values. That matters: the whole reason cues
+* pin synchronously is that one frame of the destination layout is visible
+* otherwise, and a barrier that yielded would hand that frame back.
+*
+* The pairing itself is the same shape as the counterpart matching a region
+* already does within itself. The receiving element is the one that flies: it
+* takes the sender's bounds as an `initial` it never had, and the sender is
+* dropped rather than orphaned, because the thing it would animate is already
+* being animated somewhere else.
+*
+* Bounds cross the boundary in PAGE space, which is the only space the two
+* regions agree on — a region-relative measurement means nothing to a region
+* somewhere else on the page.
+*/
+/** one region's measured pass, waiting for the others before it runs */
+var intents = /* @__PURE__ */ new Set();
+var booked = false;
+/** a seam for the region to book the callback without far.ts importing the scheduler */
+var schedule = (fn) => fn();
+function setPassScheduler(fn) {
+	schedule = fn;
+}
+/**
+* Announce that this region has a pass coming. Called while Glimmer is still
+* rendering, so by the time the barrier runs, every region taking part in this
+* pass is known — which is what lets the match be synchronous.
+*/
+function join(host) {
+	intents.add(host);
+	if (!booked) {
+		booked = true;
+		schedule(runBarrier);
+	}
+}
+function leave(host) {
+	intents.delete(host);
+}
+/** a booked barrier is work outstanding: nothing has measured yet */
+registerBusyProbe(() => booked && "far-match barrier booked");
+/**
+* Drop a barrier that will never run. A test torn down between `join` and the
+* post-render callback leaves a destroyed region parked in `intents`, and the
+* next test's first pass would try to measure it. `setupChoreo(hooks)` runs
+* this before and after every test.
+*/
+function resetBarrier() {
+	intents.clear();
+	booked = false;
+}
+/** mount everything rendered this pass before ANY region measures */
+var beforeMeasure = () => {};
+function setBeforeMeasure(fn) {
+	beforeMeasure = fn;
+}
+/**
+* SETTLE: state that the pass implies but that is not markup, settled after
+* this pass's mounts and before any region measures. A scroll owner (a list
+* that keeps its scroll at the newest content, or holds a row in place while
+* rows above it change) holds its anchor here: a scroll position is state,
+* so it lands in the same pass as the change that moved it, and every region
+* measures the page as the reader will see it. An element the scroll kept
+* still then reads as not moved and gets no motion; only what really moved
+* on screen does.
+*
+* A settler only runs inside a barrier, and a barrier runs only when a
+* region joins a pass: with no region mounted, every region idle, or motion
+* off, no settler runs. So the owner sets its scroll through its own path as
+* well (on render or on resize, as it would with no Choreo on the page), and
+* the settler only makes that happen before regions measure. State never
+* depends on a settler (ADR 007 §1.1).
+*
+* Settlers run in registration order; one that throws is reported and the
+* pass goes on. Returns the unregister function.
+*/
+var settlers = /* @__PURE__ */ new Set();
+function registerSettle(fn) {
+	settlers.add(fn);
+	return () => {
+		settlers.delete(fn);
+	};
+}
+function runBarrier() {
+	booked = false;
+	const hosts = [...intents];
+	intents.clear();
+	beforeMeasure();
+	for (const settle of [...settlers]) try {
+		settle();
+	} catch (e) {
+		queueMicrotask(() => {
+			throw e;
+		});
+	}
+	const passes = [];
+	for (const host of hosts) {
+		const pass = host.measurePass();
+		if (pass) passes.push(pass);
+	}
+	if (passes.length > 1) match(passes);
+	for (const pass of passes) pass.host.finishPass(pass);
+}
+var deltaOf = (s) => s.initial && s.final ? {
+	height: s.final.page.height - s.initial.page.height,
+	width: s.final.page.width - s.initial.page.width,
+	x: s.final.page.x - s.initial.page.x,
+	y: s.final.page.y - s.initial.page.y
+} : void 0;
+/**
+* Pair an id inserted in one region against the same id removed in another.
+*
+* The receiver becomes a kept sprite carrying the sender as its counterpart —
+* exactly what same-region counterpart matching produces, so every step that
+* already understands `kept` and `counterpart` works across the boundary with
+* no further teaching. The sender is flagged `sent` so its own region knows to
+* let it go quietly instead of playing a removal for it.
+*/
+function match(passes) {
+	for (const pass of passes) for (const s of pass.inserted) {
+		if (s.id === null || s.counterpart) continue;
+		for (const other of passes) {
+			if (other === pass) continue;
+			const sender = other.removed.find((r) => r.id === s.id && !r.counterpart && !r.sent);
+			if (sender) {
+				sender.sent = true;
+				s.counterpart = sender;
+				s.initial = sender.initial;
+				s.type = "kept";
+				s.delta = deltaOf(s);
+				break;
+			}
+		}
+	}
+}
+//#endregion
+//#region ../choreo/src/registry.ts
+/**
+* A region is a participant host (glimmer-motion/participant): its root
+* renders `data-motion-host` beside `data-choreo`, and registering a region
+* here registers it as that element's participant host too, so the {{motion}}
+* elements inside join it. The lookups below are Choreo's own, for code that
+* already speaks in regions.
+*/
+/** anything that can put a node on a region's timeline — a step component, or a lane from outside */
+var hosts = /* @__PURE__ */ new WeakMap();
+/** regions rendered with `@id`, so an attachment can name one without a DOM query per frame */
+var hostsById = /* @__PURE__ */ new Map();
+function setChoreoHost(el, host) {
+	const id = el.getAttribute("data-choreo");
+	if (host) {
+		hosts.set(el, host);
+		setParticipantHost(el, host);
+		if (id) hostsById.set(id, host);
+	} else {
+		const mine = hosts.get(el);
+		hosts.delete(el);
+		setParticipantHost(el, void 0);
+		if (id && mine && hostsById.get(id) === mine) hostsById.delete(id);
+	}
+}
+function closestChoreo(el) {
+	const root = el.parentElement?.closest("[data-choreo]");
+	return root ? hosts.get(root) : void 0;
+}
+/** the host of a region element itself (not an ancestor's) */
+function choreoHostAt(el) {
+	return hosts.get(el);
+}
+/** the host of the region rendered with `@id` — a lane's way of naming the region it plays in */
+function choreoHostById(id) {
+	return hostsById.get(id);
+}
+//#endregion
+//#region ../choreo/src/deliver.ts
+/**
+* Text delivery — `@by='word' | 'character' | 'paragraph'` (§4.3).
+*
+* The split is a run-time costume, not a render: the sprite's own text
+* nodes are lifted out whole and kept (Glimmer still owns them — a tracked
+* update mid-flight writes into the detached node and comes back at
+* restore), stand-in spans deliver the animation, and the restore puts the
+* original nodes back exactly where they were. Assistive tech reads the
+* full text throughout: the container carries it as a label while the
+* chopped-up copy is hidden.
+*
+* Slots play on the platform's own animations (WAAPI), not the engine:
+* they are ephemeral, their schedule is computed once, and a spring's
+* clock arrives pre-sampled through the generator — the same shape the
+* native driver uses for everything.
+*/
+var spanFor = (text) => {
+	const span = document.createElement("span");
+	span.textContent = text;
+	span.setAttribute("aria-hidden", "true");
+	span.style.display = "inline-block";
+	span.style.whiteSpace = "pre";
+	return span;
+};
+function textNodesOf(root) {
+	const out = [];
+	const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+	for (let n = walker.nextNode(); n; n = walker.nextNode()) if ((n.textContent ?? "").length) out.push(n);
+	return out;
+}
+function unitsOf(text, by) {
+	if (by === "character") return Array.from(text);
+	return text.match(/\S+\s*|\s+/g) ?? [];
+}
+function split(el, by) {
+	if (by === "paragraph") {
+		const slots = Array.from(el.children).filter((c) => c instanceof HTMLElement);
+		if (!slots.length) throw new Error("choreo: @by='paragraph' needs child elements to deliver");
+		return {
+			restore() {},
+			slots: slots.map((s) => ({ el: s }))
+		};
+	}
+	const originals = textNodesOf(el);
+	if (!originals.length) throw new Error(`choreo: @by='${by}' needs text to deliver`);
+	const ws = getComputedStyle(el).whiteSpace;
+	const collapsing = ws === "normal" || ws === "nowrap" || ws === "pre-line";
+	const textOf = (node, index) => {
+		let text = node.textContent ?? "";
+		if (collapsing) {
+			text = text.replace(/\s+/g, " ");
+			if (index === 0) text = text.replace(/^ /, "");
+			if (index === originals.length - 1) text = text.replace(/ $/, "");
+		}
+		return text;
+	};
+	const label = el.getAttribute("aria-label");
+	el.setAttribute("aria-label", el.textContent ?? "");
+	const slots = [];
+	const undo = [];
+	for (const [index, node] of originals.entries()) {
+		const parent = node.parentNode;
+		const marker = document.createComment("choreo-delivery");
+		parent.replaceChild(marker, node);
+		const spans = [];
+		for (const unit of unitsOf(textOf(node, index), by)) {
+			const span = spanFor(unit);
+			parent.insertBefore(span, marker);
+			spans.push(span);
+			if (by === "character" && /^\s+$/.test(unit)) continue;
+			slots.push({ el: span });
+		}
+		undo.push(() => {
+			for (const span of spans) span.remove();
+			marker.parentNode?.replaceChild(node, marker);
+		});
+	}
+	let restored = false;
+	return {
+		restore() {
+			if (restored) return;
+			restored = true;
+			undo.reverse().forEach((fn) => fn());
+			if (label === null) el.removeAttribute("aria-label");
+			else el.setAttribute("aria-label", label);
+		},
+		slots
+	};
+}
+/**
+* `@stagger` seconds between starts, window = what remains of the span; with
+* no stagger, the Build Order demo's policy: a 0.55-of-span window with the
+* starts distributed across the remainder.
+*/
+function windows(n, span, stagger) {
+	if (n <= 1 || span <= 0) return Array.from({ length: n }, () => ({
+		at: 0,
+		ms: span
+	}));
+	if (stagger > 0) {
+		const ms = Math.max(1, span - (n - 1) * stagger);
+		return Array.from({ length: n }, (_, i) => ({
+			at: i * stagger,
+			ms
+		}));
+	}
+	const ms = span * .55;
+	return Array.from({ length: n }, (_, i) => ({
+		at: i * (span - ms) / (n - 1),
+		ms
+	}));
+}
+var UNITLESS = new Set([
+	"opacity",
+	"scale",
+	"scaleX",
+	"scaleY"
+]);
+var TRANSFORMS = {
+	rotate: (v) => `rotate(${v}deg)`,
+	scale: (v) => `scale(${v})`,
+	x: (v) => `translateX(${v}px)`,
+	y: (v) => `translateY(${v}px)`
+};
+/**
+* cue.target without the keys that move a box: the positional keys motion-dom
+* jumps rather than animates when motion is reduced. Opacity, colour and
+* filters are left to animate.
+*/
+function withoutMovement(target) {
+	const out = {};
+	for (const key in target) if (!positionalKeys.has(key)) out[key] = target[key];
+	return out;
+}
+/** cue.target, as WAAPI property-indexed keyframes */
+function keyframesOf(target, times, ease) {
+	const out = {};
+	const transforms = /* @__PURE__ */ new Map();
+	for (const key in target) {
+		const raw = target[key];
+		const values = (Array.isArray(raw) ? raw : [raw]).map(String);
+		if (TRANSFORMS[key]) transforms.set(key, values);
+		else out[UNITLESS.has(key) || isNaN(Number(values[0])) ? key : key] = values;
+	}
+	if (transforms.size) {
+		const length = Math.max(...[...transforms.values()].map((v) => v.length));
+		const frames = [];
+		for (let i = 0; i < length; i++) {
+			const parts = [];
+			for (const [key, values] of transforms) parts.push(TRANSFORMS[key](values[Math.min(i, values.length - 1)]));
+			frames.push(parts.join(" "));
+		}
+		out["transform"] = frames;
+	}
+	return times ? {
+		...out,
+		offset: times,
+		easing: times.map(() => ease ?? "linear")
+	} : out;
+}
+var NAMED = {
+	anticipate: "cubic-bezier(0.68,-0.6,0.32,1.6)",
+	backIn: "cubic-bezier(0.36,0,0.66,-0.56)",
+	backInOut: "cubic-bezier(0.68,-0.6,0.32,1.6)",
+	backOut: "cubic-bezier(0.34,1.56,0.64,1)",
+	circIn: "cubic-bezier(0.55,0,1,0.45)",
+	circInOut: "cubic-bezier(0.85,0,0.15,1)",
+	circOut: "cubic-bezier(0,0.55,0.45,1)",
+	easeIn: "ease-in",
+	easeInOut: "ease-in-out",
+	easeOut: "ease-out",
+	linear: "linear"
+};
+function cssEasing(ease, ms) {
+	if (ease === void 0) return "ease-in-out";
+	if (typeof ease === "string") return NAMED[ease] ?? "ease-in-out";
+	if (Array.isArray(ease)) return `cubic-bezier(${ease.join(",")})`;
+	return generateLinearEasing(ease, ms);
+}
+/** a spring's clock, pre-sampled: its real duration and a linear() easing */
+function springEasing(spec) {
+	const generator = spring({
+		keyframes: [0, 100],
+		...spec ?? {}
+	});
+	const ms = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+	const progress = (t) => generator.next(t * ms).value / 100;
+	return {
+		easing: generateLinearEasing(progress, ms),
+		ms
+	};
+}
+/**
+* play one delivery cue: split, animate the slots, restore, land the end
+* values. With `reduced`, the slots keep their windows but not their
+* movement: a word fades in where it stands rather than rising into place.
+*/
+function deliver(cue, speed, reduced = false) {
+	const { by, order, stagger } = cue.delivery;
+	if (by === "item") throw new Error("choreo: item delivery is the ladder, not a split");
+	const parts = split(cue.sprite.element, by);
+	const ranks = ladder(parts.slots.length, order);
+	const spans = windows(parts.slots.length, cue.duration, stagger);
+	const times = cue.transition?.times;
+	const target = reduced ? withoutMovement(cue.target) : cue.target ?? {};
+	const keyframes = keyframesOf(target, Object.keys(target).length ? times : void 0, cssEasing(cue.transition?.ease, cue.duration));
+	const sprung = cue.kind === "spring" ? springEasing(cue.transition) : void 0;
+	const animations = [];
+	for (const [index, slot] of parts.slots.entries()) {
+		const w = spans[ranks[index] ?? index];
+		const ms = sprung ? Math.min(sprung.ms, w.ms) : w.ms;
+		animations.push(slot.el.animate(keyframes, {
+			delay: w.at * speed,
+			duration: Math.max(1, ms * speed),
+			easing: times ? "linear" : sprung ? sprung.easing : cssEasing(cue.transition?.ease, ms),
+			fill: "both"
+		}));
+	}
+	let done = false;
+	let held = false;
+	const land = () => {
+		if (done) return;
+		done = true;
+		const ve = cue.sprite.node.visualElement;
+		if (ve && cue.target) {
+			for (const key in cue.target) {
+				const raw = cue.target[key];
+				const end = Array.isArray(raw) ? raw[raw.length - 1] : raw;
+				ve.getValue(key, end).jump(end);
+			}
+			ve.render();
+		}
+		parts.restore();
+	};
+	return {
+		cancel() {
+			done = true;
+			animations.forEach((a) => a.cancel());
+			parts.restore();
+		},
+		complete() {
+			animations.forEach((a) => {
+				try {
+					a.finish();
+				} catch {
+					a.cancel();
+				}
+			});
+			land();
+		},
+		finished: Promise.all(animations.map((a) => a.finished.catch(() => {}))).then(land),
+		get inFlight() {
+			return !done && !held;
+		},
+		pause() {
+			held = true;
+			animations.forEach((a) => a.pause());
+		},
+		play() {
+			held = false;
+			animations.forEach((a) => a.play());
+		},
+		seek(ms) {
+			const t = Math.max(0, ms * speed);
+			animations.forEach((a) => a.currentTime = t);
+		},
+		speed(rate) {
+			animations.forEach((a) => a.playbackRate = rate);
+		}
+	};
+}
+//#endregion
+//#region ../choreo/src/path.ts
+/**
+* THE CAMERA'S PATH — the arithmetic behind `c.Camera3D @through`, and
+* the only place in Choreo that owns a curve rather than a tween.
+*
+* Everything here is a pure function of PROGRESS. That is the whole
+* point: a seek must land the shot exactly where playing there would, so
+* nothing in this file may remember a previous frame. A spline that is
+* sampled rather than integrated can be scrubbed, rendered a frame at a
+* time, and played, and all three agree by construction.
+*/
+/**
+* One cardinal-spline component: Hermite through p1 and p2, tangents off
+* p0 and p3 scaled by `k = (1 - tension) / 2`. Tension 0 is the classic
+* Catmull-Rom — lively, and loose enough to overshoot between waypoints
+* that change direction; 1 collapses the tangents and the path goes
+* piecewise-linear. The default (0.5) is the steady hand: it still crosses
+* every waypoint with continuous velocity, but it does not sway on the way.
+*/
+function crVal(p0, p1, p2, p3, u, k) {
+	const m1 = k * (p2 - p0);
+	const m2 = k * (p3 - p1);
+	const u2 = u * u;
+	const u3 = u2 * u;
+	return (2 * u3 - 3 * u2 + 1) * p1 + (u3 - 2 * u2 + u) * m1 + (-2 * u3 + 3 * u2) * p2 + (u3 - u2) * m2;
+}
+/**
+* Resolve a `@through` path's control points: the pose in force first, then
+* each waypoint with its omissions carried forward. If ANY point carries a
+* look, every point gets one (the origin, when unstated), so the aim is
+* splined by the same arithmetic as the pose.
+*/
+function resolveThrough(from, through) {
+	const aimed = !!from.look || through.some((w) => w.look);
+	const seed = {
+		...from,
+		look: aimed ? from.look ?? {
+			x: 0,
+			y: 0,
+			z: 0
+		} : void 0
+	};
+	const pts = [seed];
+	let prev = seed;
+	for (const w of through) {
+		const p = {
+			dolly: w.dolly ?? prev.dolly,
+			look: aimed ? w.look ?? prev.look : void 0,
+			pitch: w.pitch ?? prev.pitch,
+			x: w.x ?? prev.x,
+			y: w.y ?? prev.y,
+			yaw: w.yaw ?? prev.yaw
+		};
+		pts.push(p);
+		prev = p;
+	}
+	return pts;
+}
+/** the shot a slot position falls in — points [a, e), window [w0, w1) */
+/**
+* WHICH SHOT A SLOT POSITION IS IN. A waypoint marked `cut` opens a new
+* one, and the two facts a caller needs about it are the points it may
+* reach for and the slice of the clock it owns — the second so that
+* nothing (a sample, a settle) ever reads across a seam.
+*/
+function shotAt(through, points, segs, s) {
+	let seams;
+	for (const [n, w] of through.entries()) if (w.cut) (seams ??= []).push(n + 1);
+	let a = 0;
+	let e = points;
+	let w0 = 0;
+	let w1 = segs;
+	if (seams) {
+		if (seams[0] === 1) {
+			a = 1;
+			seams = seams.slice(1);
+		}
+		for (const seam of seams) {
+			if (s < seam) {
+				e = seam;
+				w1 = seam;
+				break;
+			}
+			a = seam;
+			w0 = seam;
+		}
+	}
+	return {
+		a,
+		e,
+		w0,
+		w1
+	};
+}
+/**
+* Sample the spline at overall progress p ∈ [0, 1] (uniform segments).
+*
+* SPLICES (packages/choreo-gallery/realm/docs/choreo-splices.md): a waypoint marked `cut` starts a new
+* SHOT. Each shot is a clamped spline of its own points — endpoint
+* tangents one-sided, so no shot's velocity crosses a seam — and each
+* shot's window runs from its first slot to the next seam, its points
+* spread uniformly across it. The outgoing shot therefore plays through
+* the seam instant (its motion stretches by one slot rather than
+* parking), the incoming one begins exactly on it, and the sampled pose
+* is a step function at the seam. Waypoints keep their uniform slots, so
+* cues anchored to waypoint moments keep their clock. A cut on the first
+* waypoint drops the pose-in-force seed: the score opens inside its
+* first shot.
+*/
+function sampleThrough(from, through, progress, tension) {
+	const k = (1 - (tension ?? .5)) / 2;
+	const pts = resolveThrough(from, through);
+	const segs = pts.length - 1;
+	const s = Math.min(segs - 1e-9, Math.max(0, progress * segs));
+	const { a, e, w0, w1 } = shotAt(through, pts.length, segs, s);
+	const m = e - a;
+	const ss = (m === 1 ? 0 : Math.max(0, Math.min(.999999999, (s - w0) / (w1 - w0)))) * (m - 1);
+	const i = a + Math.floor(ss);
+	const u = m === 1 ? 0 : ss - Math.floor(ss);
+	const P = (j) => pts[Math.max(a, Math.min(e - 1, j))];
+	const p0 = P(i - 1);
+	const p1 = P(i);
+	const p2 = P(i + 1);
+	const p3 = P(i + 2);
+	const v = (key) => crVal(p0[key], p1[key], p2[key], p3[key], u, k);
+	const out = {
+		dolly: v("dolly"),
+		pitch: v("pitch"),
+		x: v("x"),
+		y: v("y"),
+		yaw: v("yaw")
+	};
+	if (p1.look && p2.look) {
+		const l = (a) => crVal((p0.look ?? p1.look)[a], p1.look[a], p2.look[a], (p3.look ?? p2.look)[a], u, k);
+		out.look = {
+			x: l("x"),
+			y: l("y"),
+			z: l("z")
+		};
+	}
+	return out;
+}
+/**
+* A SETTLE — the operator's second hand, written as a function of time.
+*
+* A cardinal spline crosses its waypoints with continuous velocity but
+* not continuous acceleration: at every control point the curvature
+* steps, and the eye reads that step as a tick. The usual cure is a
+* spring chasing the pose, which works and costs the two things a
+* seekable engine cannot pay — it remembers the last frame, so a scrub
+* lands somewhere a play would not, and it lags, so the camera is always
+* behind the score by however much smoothing it was given.
+*
+* This is the same cure without either cost: the reported pose is a
+* Hann-weighted average of the SAME spline sampled around the current
+* progress. Averaging a curve is a low-pass filter, and a Hann window
+* kills the acceleration steps outright, so the result is a hand rather
+* than a mechanism. Being centred, it has no lag — it reads slightly
+* ahead of the score exactly as much as it reads behind. Being an
+* average of one pure function, it is still a pure function: play,
+* scrub and frame-by-frame render all report the same pose.
+*
+* TWO EDGES IT MUST NOT CROSS. A cut is a step in the pose on purpose,
+* and an average that straddled it would smear the cut into a very fast
+* pan. The window is therefore TAPERED to the shot the progress is in:
+* near either edge the kernel shrinks to the room it has, reaching zero
+* at the edge itself. So a cut stays a cut, a path still lands exactly
+* on its last waypoint, and the pose handed forward to the next cue is
+* the waypoint rather than an average of one — the filter is an identity
+* at every boundary and a smoother everywhere else.
+*
+* The taper is `tanh`, not a `min`, and the difference is the whole
+* reason it works. A hard `min(width, 2 × room)` has a corner in it
+* where the two branches meet, and a filter whose width has a corner
+* puts one back into what it filters: measured against a path with two
+* right-angle corners in it, the hard taper LOST ground as the window
+* widened (worst jerk 8.7e-4 at a window of 0.175, 2.5e-3 at 0.3) while
+* the smooth one held 8.0e-4 at every width against 4.2e-3 unfiltered.
+* `tanh(x) ≤ x` everywhere, which is what keeps the taps inside the
+* shot; it is smooth, which is what keeps the tick out.
+*
+* `width` is in progress, not seconds: the kinks being filtered are at
+* the waypoints, which are spread uniformly across the clock, so a
+* window measured against the clock is a window measured against the
+* spacing of the things it exists to smooth. The caller converts.
+*/
+function settleThrough(from, through, progress, tension, width, taps = 15) {
+	const pts = resolveThrough(from, through);
+	const segs = pts.length - 1;
+	const s = Math.min(segs - 1e-9, Math.max(0, progress * segs));
+	const { w0, w1 } = shotAt(through, pts.length, segs, s);
+	const lo = w0 / segs;
+	const hi = w1 / segs;
+	const p = Math.min(hi, Math.max(lo, progress));
+	const room = Math.min(p - lo, hi - p);
+	const w = width > 0 ? width * Math.tanh(2 * room / width) : 0;
+	if (!(w > 1e-6) || taps < 3) return sampleThrough(from, through, progress, tension);
+	const aimed = !!from.look || through.some((t) => t.look);
+	let sum = 0;
+	let dolly = 0;
+	let pitch = 0;
+	let x = 0;
+	let y = 0;
+	let yaw = 0;
+	let lx = 0;
+	let ly = 0;
+	let lz = 0;
+	for (let i = 0; i < taps; i += 1) {
+		const f = (i + 1) / (taps + 1);
+		const weight = .5 - .5 * Math.cos(2 * Math.PI * f);
+		const q = sampleThrough(from, through, p + (f - .5) * w, tension);
+		sum += weight;
+		dolly += weight * q.dolly;
+		pitch += weight * q.pitch;
+		x += weight * q.x;
+		y += weight * q.y;
+		yaw += weight * q.yaw;
+		if (aimed && q.look) {
+			lx += weight * q.look.x;
+			ly += weight * q.look.y;
+			lz += weight * q.look.z;
+		}
+	}
+	const out = {
+		dolly: dolly / sum,
+		pitch: pitch / sum,
+		x: x / sum,
+		y: y / sum,
+		yaw: yaw / sum
+	};
+	if (aimed) out.look = {
+		x: lx / sum,
+		y: ly / sum,
+		z: lz / sum
+	};
+	return out;
+}
+//#endregion
+//#region ../choreo/src/run.ts
+/**
+* Play a cue list on the motion-dom engine — as a run you can hold (§4.6).
+*
+* The old executor fired timers and forgot; this one owns a master clock.
+* Cues start when the clock crosses them, a gate parks the clock until
+* `advance()` (§4.1), `time` is settable in either direction (a scrubbed
+* frame is a still), and `speed` scales the whole score. Ambient loops and
+* text deliveries ride the platform's own animations, so a busy probe never
+* mistakes an idle loop for motion.
+*
+* The clock runs in tempo-scaled milliseconds; the public face (`time`,
+* `duration`) speaks seconds at 1×, as Motion's playback controls do.
+*/
+/** the properties whose mid-flight drive means a sprite is IN SPACE — a
+*  replacement pass must carry these on, never snap them (§3.1) */
+var MIDFLIGHT_KEYS = [
+	"height",
+	"rotate",
+	"scale",
+	"scaleX",
+	"scaleY",
+	"width",
+	"x",
+	"y"
+];
+/** how fast each value was moving, in units per second, keyed by element then property */
+/**
+* Where each ambient loop stood in its cycle, from 0 to 1, keyed by sprite
+* then by the loop's properties (see loopKey).
+*/
+/** a loop's properties, which tell it apart from another loop on its sprite */
+var loopKey = (cue) => Object.keys(cue.target ?? {}).sort().join(",");
+/** a tween a replacement pass carries on: see Run.midfade */
+function isSpring(transition) {
+	if (!transition) return false;
+	if (transition["type"]) return transition["type"] === "spring";
+	return "bounce" in transition || "damping" in transition || "stiffness" in transition || "visualDuration" in transition;
+}
+/**
+* Controls that wrap a platform Animation rather than a motion-dom one: the
+* frame clock's hold-back has no tween to move in them, and no private
+* fields to find.
+*/
+var platformControlled = /* @__PURE__ */ new WeakSet();
+/**
+* A platform Animation in the controls shape the transport speaks, so
+* setPaused / speed / stopTrack drive it exactly like an engine animation.
+*/
+function platformControls(animation) {
+	const controls = {
+		cancel: () => animation.cancel(),
+		pause: () => animation.pause(),
+		play: () => animation.play(),
+		get speed() {
+			return animation.playbackRate;
+		},
+		set speed(rate) {
+			animation.playbackRate = rate;
+		},
+		get state() {
+			return animation.playState;
+		},
+		stop: () => animation.cancel(),
+		get time() {
+			return (animation.currentTime ?? 0) / 1e3;
+		},
+		set time(seconds) {
+			animation.currentTime = seconds * 1e3;
+		}
+	};
+	platformControlled.add(controls);
+	return controls;
+}
+function carryVelocity(transition, cue, inherit) {
+	if (!inherit || !cue.target || !isSpring(transition)) return transition;
+	const was = inherit.get(cue.sprite.element) ?? (cue.sprite.counterpart && inherit.get(cue.sprite.counterpart.element));
+	if (!was) return transition;
+	let out = transition;
+	for (const key in cue.target) {
+		const velocity = was.get(key);
+		if (velocity) {
+			if (out === transition) out = { ...transition };
+			out[key] = {
+				...transition,
+				velocity
+			};
+		}
+	}
+	return out;
+}
+var dash = (key) => key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+var noop = () => {};
+var SIZES = {
+	height: true,
+	width: true
+};
+function applyHold(ve, el, values) {
+	const held = [];
+	for (const key in values) {
+		const had = ve.hasValue(key);
+		const prior = had ? ve.getValue(key).get() : void 0;
+		const priorStyle = key.startsWith("--") ? el.style.getPropertyValue(key) : el.style[key] ?? "";
+		ve.getValue(key, values[key]).jump(values[key]);
+		held.push({
+			had,
+			key,
+			prior,
+			priorStyle
+		});
+	}
+	ve.scheduleRender();
+	return held;
+}
+function releaseHold(ve, el, held) {
+	for (const { had, key, prior, priorStyle } of held) if (had) ve.getValue(key)?.jump(prior);
+	else {
+		ve.removeValue(key);
+		if (priorStyle) el.style.setProperty(dash(key), priorStyle);
+		else el.style.removeProperty(dash(key));
+	}
+	ve.scheduleRender();
+}
+/** what one cue is doing right now */
+var warnedPrivateFields = false;
+/** let the next run that misses motion-dom's private fields say so again (a test's reset) */
+function resetRunWarnings() {
+	warnedPrivateFields = false;
+}
+/** the run's frame clock reads motion-dom's private animation fields; say once when they are gone */
+function warnPrivateFieldsMoved() {
+	if (warnedPrivateFields) return;
+	warnedPrivateFields = true;
+	console.warn("@cardstack/choreo: motion-dom no longer exposes the animation fields a run's frame clock reads (_animation, startTime, holdTime); a run compiled in a long task will open its tweens that far in, and with @maxFrameStep a long frame will skip them ahead instead of slowing them");
+}
+var ChoreoRun = class ChoreoRun {
+	cues;
+	velocities = /* @__PURE__ */ new Map();
+	finished;
+	master = 0;
+	playing = true;
+	parkedAt = null;
+	rate = 1;
+	scale = motionSpeed();
+	reduced;
+	standing;
+	total;
+	gates;
+	tracks = [];
+	rowEnd = /* @__PURE__ */ new Map();
+	released = /* @__PURE__ */ new Set();
+	pending;
+	options;
+	borrowedValues = [];
+	/** rest is what releaseForMeasure jumps to: 0 for translates, 1 for scales, 'none' for clips */
+	movedValues = [];
+	/** what the last releaseForMeasure retired, so a kept pass can put it back */
+	retired = {
+		borrowed: [],
+		moved: []
+	};
+	owned = [];
+	cancelled = false;
+	ended = false;
+	resolveFinished;
+	ticking = false;
+	/**
+	* The next tick is the first since the clock started (or resumed): it
+	* paints the run where it stands and advances nothing. The frame loop's
+	* delta on that tick is the time since ITS last frame, up to 40 ms, so a
+	* run started by a render pass would otherwise open with that whole step
+	* on its own clock: every cue the clock starts, gates, or drives frame by
+	* frame (a camera, a wire, a later cue's start) would begin that far in.
+	* The tweens the run started get the same fresh start from holdBack. A
+	* run that opens `continuing` skips it.
+	*/
+	freshClock = false;
+	/**
+	* The run replaces one in flight and has not painted yet. Its first frame
+	* continues a motion already on screen, so it advances like any other
+	* frame, the clock and its tweens alike: standing still there would draw
+	* the last frame twice. A later start (a resume, a gate) is from rest.
+	*/
+	continuing = false;
+	/** the frame timestamp holdBack saw last; undefined before its first frame */
+	lastStamp;
+	/**
+	* motion-dom's clock as the run (re)started ticking. That clock holds one
+	* reading until the microtask queue next drains, and startTicking reads it
+	* in the same synchronous call that started or resumed the run's tweens,
+	* so this is the time they were dated from, however long the task ran
+	* before it.
+	*/
+	startedAt = 0;
+	autoTimer;
+	constructor(compiled, options) {
+		this.options = options;
+		this.continuing = options.continuing ?? false;
+		this.reduced = options.reduced ?? false;
+		this.camera = options.camera ?? {
+			x: 0,
+			y: 0,
+			zoom: 1
+		};
+		this.camera3d = options.camera3d ?? {
+			dolly: 1,
+			pitch: 0,
+			x: 0,
+			y: 0,
+			yaw: 0
+		};
+		this.initial3d = { ...this.camera3d };
+		this.cameraAim = options.cameraAim ?? null;
+		this.initialCamera = { ...this.camera };
+		this.initialAim = this.cameraAim ? { ...this.cameraAim } : null;
+		this.cues = compiled.cues;
+		this.pending = new Set(options.removed);
+		const s = this.scale;
+		this.gates = compiled.gates.map((g) => ({
+			at: g.at * s,
+			auto: g.auto === void 0 ? void 0 : g.auto * s,
+			opened: false
+		}));
+		this.standing = compiled.open ?? false;
+		let total = 0;
+		for (const cue of this.cues) {
+			const start = cue.start * s;
+			const duration = cue.duration * s;
+			this.tracks.push({
+				cue,
+				end: start + duration,
+				passed: false,
+				start,
+				started: false
+			});
+			if (!cue.loop && !cue.standing) total = Math.max(total, start + duration);
+			this.rowEnd.set(cue.sprite, Math.max(this.rowEnd.get(cue.sprite) ?? 0, cue.standing ? start : start + duration));
+		}
+		for (const g of this.gates) total = Math.max(total, g.at);
+		for (const [sprite, end] of this.rowEnd) if (sprite.counterpart) this.rowEnd.set(sprite.counterpart, Math.max(this.rowEnd.get(sprite.counterpart) ?? 0, end));
+		this.total = total;
+		this.finished = new Promise((resolve) => {
+			this.resolveFinished = resolve;
+		});
+		this.pinStarts();
+		this.evaluate();
+		this.startTicking();
+		activeRuns.add(this);
+		this.finished.then(() => activeRuns.delete(this));
+	}
+	get duration() {
+		return this.total / this.scale / 1e3;
+	}
+	get paused() {
+		return !this.playing;
+	}
+	get time() {
+		return this.master / this.scale / 1e3;
+	}
+	/**
+	* The run's motion is under way on screen: it is playing, its clock has
+	* not reached its end, and it has painted a frame since it started or
+	* resumed, or carries on a run that had. A run compiled and replaced
+	* before any frame was never seen moving, so its replacement starts from
+	* rest.
+	*/
+	get inFlight() {
+		return this.ticking && this.master < this.total && (this.lastStamp !== void 0 || this.continuing);
+	}
+	set time(seconds) {
+		this.seekTo(seconds * 1e3 * this.scale);
+	}
+	get speed() {
+		return this.rate;
+	}
+	set speed(rate) {
+		this.rate = rate;
+		for (const t of this.tracks) {
+			t.controls?.forEach((c) => c.speed = rate);
+			if (t.delivery) t.delivery.speed(rate);
+			if (t.loopAnimation) t.loopAnimation.playbackRate = rate;
+			if (t.cameraAnimation) t.cameraAnimation.playbackRate = rate;
+		}
+	}
+	get segment() {
+		let n = 0;
+		for (const g of this.gates) if (this.master > g.at || this.master === g.at && g.opened) n++;
+		return n;
+	}
+	get parked() {
+		return this.parkedAt !== null;
+	}
+	/**
+	* ATTACH: write each attached region's clock from this one's.
+	*
+	* Several windows may name one region — a film's every beat has a plate
+	* window, and the plate is one region re-keyed per beat — so the run
+	* resolves ONE governing window per region on every evaluate: the window
+	* that holds `now`; else the latest past one, if it holds; else the
+	* earliest future one, which stands the child at its head (Remotion's
+	* premount: mounted early, clock frozen at `in`). The child's run is
+	* paused and told `in + (now − start) × rate`. No history is kept on
+	* either side, which is what makes a seek into a window land where
+	* playing there would.
+	*/
+	driveAttachments(now) {
+		let governing;
+		for (const t of this.tracks) {
+			const a = t.cue.attach;
+			if (!a || t.refused) continue;
+			governing ??= /* @__PURE__ */ new Map();
+			const g = governing.get(a.region);
+			if (!g) {
+				governing.set(a.region, t);
+				continue;
+			}
+			const rank = (x) => now >= x.start && now < x.end ? 2 : now >= x.end ? 1 : 0;
+			const rt = rank(t);
+			const rg = rank(g);
+			if (rt > rg || rt === rg && rt === 1 && t.end > g.end || rt === rg && rt === 0 && t.start < g.start) governing.set(a.region, t);
+		}
+		if (!governing) return;
+		for (const [region, t] of governing) {
+			const a = t.cue.attach;
+			const child = choreoHostById(region)?.currentRun() ?? null;
+			if (!child || child === this) continue;
+			if (a.exact && child.hasIntegrator()) {
+				t.refused = true;
+				console.error(`choreo: <Choreo "${region}"> is attached under an exact clock, but its score integrates (a spring or a follow): its state is its history, and a driven clock has none`);
+				continue;
+			}
+			let local;
+			if (now < t.start) local = a.in;
+			else if (now < t.end) local = a.in + (now - t.start) / 1e3 / this.scale * a.rate;
+			else if (a.end === "hold") local = a.in + t.cue.duration / 1e3 * a.rate;
+			else continue;
+			const inside = now >= t.start && now < t.end;
+			if (this.playing && inside && !this.ended) {
+				if (child.paused) {
+					child.time = local;
+					child.play();
+				} else if (Math.abs(child.time - local) > 1 / 30) child.time = local;
+				const speed = this.rate * a.rate;
+				if (Math.abs(child.speed - speed) > 1e-6) child.speed = speed;
+				continue;
+			}
+			if (!child.paused) child.pause();
+			if (Math.abs(child.time - local) > 1e-4) child.time = local;
+		}
+	}
+	/** does this run's score integrate — a spring, a follow — so that its state is its history? */
+	hasIntegrator() {
+		return this.tracks.some((t) => t.cue.kind === "spring" || !!t.cue.derive);
+	}
+	isDone() {
+		return this.ended || this.cancelled;
+	}
+	isLooping() {
+		return this.ended && !this.cancelled && this.tracks.length > 0 && this.tracks.every((t) => t.cue.loop && t.loopAnimation !== void 0 && t.loopAnimation.playState !== "idle");
+	}
+	/**
+	* A text delivery is still standing in for its sprite's text. The clock
+	* can end first: a delivery lands on its own platform animations, and the
+	* run leaves it to finish its tail rather than cutting it short.
+	*/
+	get delivering() {
+		return !this.cancelled && this.tracks.some((t) => t.delivery?.inFlight === true);
+	}
+	loopPhases() {
+		const out = /* @__PURE__ */ new Map();
+		for (const t of this.tracks) {
+			const animation = t.loopAnimation;
+			if (!animation || animation.playState === "idle") continue;
+			const cycle = Number(animation.effect?.getComputedTiming().duration);
+			if (!(cycle > 0)) continue;
+			const node = t.cue.sprite.node;
+			let phases = out.get(node);
+			if (!phases) out.set(node, phases = /* @__PURE__ */ new Map());
+			phases.set(loopKey(t.cue), Number(animation.currentTime ?? 0) % cycle / cycle);
+		}
+		return out;
+	}
+	midflight() {
+		const out = /* @__PURE__ */ new Map();
+		if (this.isDone()) return out;
+		for (const t of this.tracks) {
+			const { cue } = t;
+			if (!t.started || t.passed) continue;
+			if (cue.flight !== void 0 || cue.target !== void 0 && MIDFLIGHT_KEYS.some((key) => key in cue.target)) out.set(cue.sprite.node, cue.transition);
+		}
+		return out;
+	}
+	midfade() {
+		const out = /* @__PURE__ */ new Map();
+		if (this.isDone()) return out;
+		const now = this.master;
+		const gate = this.gates.find((g) => !g.opened && g.at >= now)?.at;
+		const scale = this.scale || 1;
+		for (const t of this.tracks) {
+			const { cue } = t;
+			if (t.passed || t.end <= now || gate !== void 0 && t.start >= gate && !t.started || cue.kind !== "tween" || cue.loop || cue.borrow || !cue.target) continue;
+			const { repeat, repeatType } = cue.transition ?? {};
+			const first = typeof repeat === "number" && repeat % 2 === 1 && repeatType !== "loop";
+			const to = {};
+			for (const [key, value] of Object.entries(cue.target)) {
+				if (MIDFLIGHT_KEYS.includes(key)) continue;
+				const end = Array.isArray(value) ? value[first ? 0 : value.length - 1] : value;
+				if (end !== void 0 && end !== null) to[key] = end;
+			}
+			if (!Object.keys(to).length) continue;
+			const begins = Math.max(now, t.start);
+			const fades = out.get(cue.sprite.node) ?? [];
+			fades.push({
+				delay: (begins - now) / scale,
+				remaining: (t.end - begins) / scale,
+				to
+			});
+			out.set(cue.sprite.node, fades);
+		}
+		return out;
+	}
+	pause() {
+		if (!this.playing) return;
+		this.playing = false;
+		this.setPaused(true);
+		this.driveAttachments(this.master);
+		this.scheduleRestill();
+	}
+	play() {
+		if (this.playing || this.ended || this.cancelled) return;
+		if (this.parkedAt) return;
+		this.playing = true;
+		this.setPaused(false);
+		this.startTicking();
+	}
+	advance() {
+		if (this.ended || this.cancelled) return;
+		const gate = this.parkedAt;
+		if (gate) {
+			gate.opened = true;
+			this.parkedAt = null;
+			clearTimeout(this.autoTimer);
+			this.playing = true;
+			this.setPaused(false);
+			this.startTicking();
+			return;
+		}
+		const next = this.gates.find((g) => !g.opened && g.at >= this.master);
+		this.seekTo(next ? next.at : this.total);
+		if (!next && this.master >= this.total && !this.standing) this.finish();
+	}
+	retreat() {
+		if (this.cancelled) return false;
+		const eps = 1e-6;
+		const behind = this.gates.filter((g) => g.at < this.master - eps);
+		const target = behind[behind.length - 1];
+		if (!target) return false;
+		clearTimeout(this.autoTimer);
+		for (const g of this.gates) if (g.at >= target.at) g.opened = false;
+		this.ended = false;
+		this.master = Math.max(0, target.at - .5);
+		this.playing = false;
+		this.setPaused(true);
+		this.evaluate();
+		this.park(target, false);
+		return true;
+	}
+	startTicking() {
+		if (this.ticking || !this.playing || this.cancelled || this.ended) return;
+		this.ticking = true;
+		this.freshClock = !this.continuing;
+		this.lastStamp = void 0;
+		this.startedAt = time.now();
+		frame.read(this.holdBack, !!this.options.maxFrameStep);
+		frame.update(this.tick, true);
+	}
+	stopTicking() {
+		if (this.ticking) {
+			this.ticking = false;
+			this.continuing = false;
+			cancelFrame(this.tick);
+			cancelFrame(this.holdBack);
+		}
+	}
+	/** what one painted frame advances a running clock: the frame loop's delta, capped */
+	frameStep(data) {
+		const step = this.options.maxFrameStep;
+		return step ? Math.min(data.delta, step) : data.delta;
+	}
+	/**
+	* The fresh start and maxFrameStep for the animations themselves. The
+	* run's own clock gets both in tick; the tweens and springs it started
+	* run on motion-dom's frame clock, which takes the real time since their
+	* start, so they would open and skip on their own. Before they update,
+	* each one driven on the main thread has its start moved:
+	*
+	* - on the first frame the run paints, to this frame, less the progress
+	*   it had as the run started. A tween the pass began was dated from
+	*   motion-dom's clock, which holds one reading through a synchronous
+	*   stretch of work, so a pass late in a long one would date it back to
+	*   that reading and its first frame would show that much of it gone; it
+	*   opens at zero instead. A tween resuming with the run is dated from
+	*   the same reading less its held time, and keeps it. Every way the
+	*   clock stops (a pause, a gate, a seek) holds the run's tweens first,
+	*   and no gate stands inside a parallel, so no tween is still running
+	*   when the clock starts again. A `continuing` run moves them one
+	*   ordinary frame further, as its clock moves;
+	* - after that, with a cap, on by the time past the cap since the last
+	*   frame: it resumes from where the last frame left it, plus one step.
+	*   Without a cap this runs on the first frame only.
+	*
+	* Animations on the compositor (WAAPI) start on the frame that commits
+	* them and kept playing through a long frame; they are left alone.
+	*/
+	holdBack = (data) => {
+		const step = this.options.maxFrameStep;
+		const last = this.lastStamp;
+		this.lastStamp = data.timestamp;
+		const opening = last === void 0 && this.continuing ? this.frameStep(data) : 0;
+		if (last === void 0) this.continuing = false;
+		for (const t of this.tracks) for (const c of t.controls ?? []) {
+			if (platformControlled.has(c)) continue;
+			const inner = c._animation;
+			if (!inner || !("animation" in inner) && !("startTime" in inner && "holdTime" in inner)) warnPrivateFieldsMoved();
+			if (!inner || "animation" in inner || typeof inner.startTime !== "number" || inner.holdTime !== null) continue;
+			if (last === void 0) {
+				const progress = Math.max(0, this.startedAt - inner.startTime);
+				inner.startTime = data.timestamp - progress - opening;
+			} else if (step && data.timestamp - last > step) inner.startTime += data.timestamp - last - step;
+		}
+	};
+	tick = (data) => {
+		if (!this.playing || this.cancelled || this.ended) {
+			this.stopTicking();
+			return;
+		}
+		const delta = this.freshClock ? 0 : this.frameStep(data);
+		this.freshClock = false;
+		const next = this.master + delta * this.rate;
+		const gate = this.gates.find((g) => !g.opened && g.at >= this.master && g.at <= next);
+		if (gate) {
+			this.master = gate.at;
+			this.evaluate(gate.at);
+			this.park(gate);
+			return;
+		}
+		this.master = next;
+		this.evaluate();
+		for (const [sprite, end] of this.rowEnd) if (this.master >= end && !this.released.has(sprite)) {
+			this.released.add(sprite);
+			if (this.pending.delete(sprite)) this.options.onSpriteDone(sprite);
+		}
+		if (this.master >= this.total && !this.standing) this.finish();
+	};
+	park(gate, auto = true) {
+		gate.opened = false;
+		this.parkedAt = gate;
+		this.playing = false;
+		this.stopTicking();
+		/**
+		* HAND BACK THE LEAVERS, but only when nobody is left to open the gate.
+		*
+		* `pending` is removed sprites and nothing else — elements a <Presence>
+		* is holding in the document only because this run undertook to see them
+		* out. Parking stops the clock (above), so from here nothing advances:
+		* every row end still ahead of `master` is unreachable, `onSpriteDone`
+		* can never fire for it, and `finished` never resolves. The Presence
+		* waits on a beat that is not coming.
+		*
+		* `doomed` is what separates that from an ordinary build, and the
+		* distinction is real rather than a hedge. A gated build parks with the
+		* same sprites pending and means it: the slide is still on screen, the
+		* click is still coming, and the leaver is meant to fly out when it
+		* arrives — releasing it there would make the item vanish instead, which
+		* is the animation the registration exists to protect. A region where
+		* every participant is leaving has no slide left to click on. Nothing
+		* stays, so nothing can ask, and the gate is waiting on an event that
+		* cannot happen.
+		*
+		* That is not hypothetical. Rack's score is a gate followed by one
+		* parallel over sixty-one tiles, held still until its slider asks — so
+		* filtering its card out of the gallery compiled a score that parked at
+		* t=0 with all sixty-one of its participants pending and a clock that
+		* never moved. Because <Presence> releases its leavers as a BATCH, those
+		* sixty-one held all forty cards leaving beside them: under the default
+		* mode the survivors never closed up, and under popLayout forty
+		* invisible cards stayed lifted over the grid taking clicks meant for
+		* the two you could see.
+		*
+		* A parked run is a STILL, in this file's own words — settled, not in
+		* flight. A still is not an exit animation, so there is nothing here to
+		* cut short. If the gate is ever opened the elements are simply gone,
+		* which is what leaving means.
+		*/
+		if (this.options.doomed) for (const sprite of [...this.pending]) {
+			this.pending.delete(sprite);
+			this.options.onSpriteDone(sprite);
+		}
+		for (const t of this.tracks) if (t.started && !t.cue.loop && !t.cue.hold && t.end <= this.master) this.completeTrack(t);
+		this.setPaused(true);
+		this.scheduleRestill();
+		if (auto && gate.auto !== void 0) this.autoTimer = setTimeout(() => {
+			if (this.parkedAt === gate && !this.cancelled) this.advance();
+		}, gate.auto / this.rate);
+	}
+	finish() {
+		if (this.ended) return;
+		this.ended = true;
+		this.stopTicking();
+		this.driveAttachments(this.master);
+		this.options.onCamera?.({ ...this.camera });
+		for (const t of this.tracks) if (t.started && !t.cue.loop && !t.cue.hold && !t.cue.delivery) this.completeTrack(t);
+		this.releaseForMeasure();
+		for (const sprite of [...this.pending]) {
+			this.pending.delete(sprite);
+			this.options.onSpriteDone(sprite);
+		}
+		this.resolveFinished();
+	}
+	setPaused(paused) {
+		const now = this.master;
+		for (const t of this.tracks) {
+			if (!t.started) continue;
+			const due = now >= t.start && (now < t.end || t.cue.loop);
+			const run = !paused && due;
+			t.controls?.forEach((c) => {
+				if (run) {
+					if (c.state === "running" || c.state === "paused") c.play();
+				} else if (c.state === "running") c.pause();
+			});
+			if (t.delivery) if (paused && now >= t.end) t.delivery.complete();
+			else (run ? t.delivery.play : t.delivery.pause)();
+			if (t.loopAnimation) if (run) t.loopAnimation.play();
+			else t.loopAnimation.pause();
+			if (t.cameraAnimation) if (run) t.cameraAnimation.play();
+			else t.cameraAnimation.pause();
+		}
+	}
+	seekTo(target) {
+		const gate = this.gates.find((g) => !g.opened && g.at >= this.master && g.at <= target);
+		const clamped = Math.max(0, Math.min(gate ? gate.at : target, this.total));
+		this.master = clamped;
+		if (this.ended && clamped < this.total) this.ended = false;
+		const wasPlaying = this.playing;
+		this.playing = false;
+		this.setPaused(true);
+		this.reconstructCameraAt(gate ? gate.at : Infinity);
+		this.evaluate(gate ? gate.at : Infinity);
+		if (gate) {
+			this.park(gate);
+			return;
+		}
+		if (wasPlaying && !this.ended) {
+			this.playing = true;
+			this.setPaused(false);
+			this.startTicking();
+			return;
+		}
+		this.scheduleRestill();
+	}
+	/**
+	* The one cost WAAPI acceleration charges a scrubbable run: a finished
+	* accelerated animation commits its finals asynchronously, and that
+	* commit can land AFTER a still's jump and overwrite it. So a still is
+	* re-asserted on the two frames after it is entered — by then any
+	* pending commit has landed, and the computed frame wins again.
+	*/
+	restillPending = 0;
+	scheduleRestill() {
+		if (this.restillPending > 0) return;
+		this.restillPending = 2;
+		const pass = () => {
+			if (this.playing || this.cancelled) {
+				this.restillPending = 0;
+				return;
+			}
+			this.restill();
+			this.restillPending -= 1;
+			if (this.restillPending > 0) frame.postRender(pass);
+		};
+		frame.postRender(pass);
+	}
+	restill() {
+		const now = this.master;
+		const rewinds = [];
+		for (const t of this.tracks) {
+			const { cue } = t;
+			if (!cue.sprite.node.visualElement || cue.camera || cue.tether) continue;
+			if (!t.started && t.origin && now < t.start) rewinds.push(t);
+			else if (t.started && !t.controls && !t.delivery && !t.loopAnimation && (cue.target || cue.flight) && now >= t.start && now < t.end) this.sampleStill(t, now);
+		}
+		this.rewind(rewinds, now);
+	}
+	evaluate(limit = Infinity) {
+		const now = this.master;
+		const rewinds = [];
+		/**
+		* The shot is FOLDED, not remembered.
+		*
+		* Every other cue kind owns an element and can be started and rewound
+		* in place. A camera3d cue owns one shared triple, and per-cue state
+		* does not survive that: seeking back from cue two to inside cue one
+		* runs cue one's lerp (correct) and then cue two's rewind (which
+		* restores the pose cue two INHERITED — cue one's end), and the
+		* second write wins because it comes later in the list. The shot
+		* ended up at the boundary value for every seek backwards.
+		*
+		* So it is recomputed from the score on every evaluate: start at the
+		* pose the run inherited, walk the cues in order, and let each one
+		* pass through, lerp, or land. A relative cue resolves against
+		* whatever the walk has accumulated by the time it is reached, which
+		* is precisely "the pose in force at cue start" — and it means a
+		* direct seek is identical to having played there, by construction
+		* rather than by bookkeeping.
+		*/
+		let shot = null;
+		for (const t of this.tracks) {
+			const { cue } = t;
+			if (t.passed && now < t.end) {
+				t.passed = false;
+				if (now < t.start && t.origin) rewinds.push(t);
+			}
+			const fill = cue.hold?.fill ?? false;
+			const inside = now >= t.start && t.start < limit && (now < t.end || cue.loop || fill);
+			if (cue.camera) {
+				if (inside && !t.started) {
+					t.started = true;
+					t.cameraFrom = { ...this.camera };
+					const aimTo = cue.camera.origin ?? this.cameraAim ?? cue.camera.centre ?? {
+						x: 0,
+						y: 0
+					};
+					t.aimFrom = this.cameraAim ?? aimTo;
+					t.aimTo = aimTo;
+					this.cameraAim = aimTo;
+					t.cameraTo = ChoreoRun.resolveCameraTo(cue.camera, t.cameraFrom);
+				} else if (!inside && t.started && now < t.start) {
+					t.started = false;
+					t.cameraTo = void 0;
+					t.cameraAnimation?.cancel();
+					t.cameraAnimation = void 0;
+					if (t.cameraFrom) {
+						this.camera = { ...t.cameraFrom };
+						this.cameraAim = t.aimFrom ?? null;
+						t.cameraP = 0;
+						this.applyCamera(t);
+					}
+				}
+				if (t.started && (now < t.end || !t.passed)) {
+					const p = now >= t.end ? 1 : this.cameraProgress(t, now - t.start);
+					const from = t.cameraFrom;
+					const to = t.cameraTo ?? ChoreoRun.resolveCameraTo(cue.camera, from);
+					t.cameraP = p;
+					this.camera = {
+						x: from.x + (to.x - from.x) * p,
+						y: from.y + (to.y - from.y) * p,
+						zoom: from.zoom + (to.zoom - from.zoom) * p
+					};
+					if (this.playing && now < t.end) {
+						if (!t.cameraAnimation) this.startCameraAnimation(t, now);
+						else if (t.cameraAnimation.playState === "paused") t.cameraAnimation.play();
+					} else if (t.cameraAnimation) if (now >= t.end) this.dropCameraAnimation(t);
+					else {
+						t.cameraAnimation.pause();
+						t.cameraAnimation.currentTime = Math.max(0, now - t.start);
+					}
+					this.applyCamera(t);
+					if (now >= t.end && this.playing && !t.passed) {
+						t.passed = true;
+						this.options.onCamera?.({ ...this.camera });
+					}
+				}
+				continue;
+			}
+			if (cue.camera3d) {
+				const from = shot ?? { ...this.initial3d };
+				const through = cue.camera3d.through;
+				if (through?.length) {
+					/**
+					* A PATH: the pose in force and the waypoints are the control
+					* points of a Catmull-Rom spline, sampled at the cue's eased
+					* progress. One clock over the whole chain, so the camera
+					* CROSSES each waypoint with continuous velocity instead of
+					* parking at it — and it stays a pure function of the clock,
+					* which no per-frame integrator can claim.
+					*/
+					if (now <= t.start) shot = from;
+					else {
+						const p = now >= t.end ? 1 : this.cameraProgress(t, now - t.start);
+						const settle = cue.camera3d.settle;
+						const span = t.end - t.start;
+						shot = settle && span > 0 ? settleThrough(from, through, p, cue.camera3d.tension, settle * 1e3 / span) : sampleThrough(from, through, p, cue.camera3d.tension);
+					}
+					continue;
+				}
+				const want = cue.camera3d.to;
+				const fromLook = from.look;
+				const to = cue.camera3d.by ? {
+					dolly: from.dolly * (want.dolly ?? 1),
+					look: want.look ? {
+						x: (fromLook?.x ?? 0) + want.look.x,
+						y: (fromLook?.y ?? 0) + want.look.y,
+						z: (fromLook?.z ?? 0) + want.look.z
+					} : fromLook,
+					pitch: from.pitch + (want.pitch ?? 0),
+					x: from.x + (want.x ?? 0),
+					y: from.y + (want.y ?? 0),
+					yaw: from.yaw + (want.yaw ?? 0)
+				} : {
+					dolly: want.dolly ?? from.dolly,
+					look: want.look ?? fromLook,
+					pitch: want.pitch ?? from.pitch,
+					x: want.x ?? from.x,
+					y: want.y ?? from.y,
+					yaw: want.yaw ?? from.yaw
+				};
+				if (now <= t.start) shot = from;
+				else {
+					const p = now >= t.end ? 1 : this.cameraProgress(t, now - t.start);
+					shot = {
+						dolly: from.dolly + (to.dolly - from.dolly) * p,
+						pitch: from.pitch + (to.pitch - from.pitch) * p,
+						x: from.x + (to.x - from.x) * p,
+						y: from.y + (to.y - from.y) * p,
+						yaw: from.yaw + (to.yaw - from.yaw) * p
+					};
+					if (to.look || fromLook) {
+						const a = fromLook ?? {
+							x: 0,
+							y: 0,
+							z: 0
+						};
+						const b = to.look ?? a;
+						shot.look = {
+							x: a.x + (b.x - a.x) * p,
+							y: a.y + (b.y - a.y) * p,
+							z: a.z + (b.z - a.z) * p
+						};
+					}
+				}
+				continue;
+			}
+			if (cue.tether) {
+				if (inside && !t.started) {
+					t.started = true;
+					const layer = this.options.tetherLayer;
+					if (layer) {
+						t.wire = document.createElementNS("http://www.w3.org/2000/svg", "path");
+						t.wire.setAttribute("data-choreo-tether", "");
+						if (t.cue.tether?.name) t.wire.setAttribute("data-thread", t.cue.tether.name);
+						layer.appendChild(t.wire);
+					}
+				} else if (!inside && t.started) {
+					t.started = false;
+					t.wire?.remove();
+					t.wire = void 0;
+				}
+				if (t.started && t.wire) this.scheduleTetherDraw();
+				continue;
+			}
+			if (cue.derive) {
+				if (inside && !t.started) {
+					t.started = true;
+					const ve = cue.sprite.node.visualElement;
+					if (ve) for (const [key, rest] of Object.entries(cue.derive.rest)) this.movedValues.push({
+						key,
+						rest,
+						ve
+					});
+				} else if (!inside && t.started) {
+					t.started = false;
+					this.restDerived(t);
+				}
+				if (t.started) this.drive(t, now);
+				continue;
+			}
+			if (cue.raise) {
+				if (inside && !t.started) {
+					t.started = true;
+					this.promote(t);
+				} else if (!inside && t.started) {
+					t.started = false;
+					this.restore(t);
+				}
+				continue;
+			}
+			if (cue.scroll) {
+				if (inside && !t.started) {
+					t.started = true;
+					this.startScroll(t);
+				} else if (!inside && t.started && now < t.start) {
+					t.started = false;
+					this.stopScroll(t, true);
+				}
+				if (t.started && t.scrolling) {
+					const p = this.flightlessProgress(t, now - t.start);
+					const { container, from, to } = t.scrolling;
+					container.scrollTop = from.top + (to.top - from.top) * p;
+					container.scrollLeft = from.left + (to.left - from.left) * p;
+					if (p >= 1 && this.playing) this.stopScroll(t, false);
+				}
+				continue;
+			}
+			if (cue.hold) {
+				if (inside && !t.started) {
+					t.started = true;
+					const ve = cue.sprite.node.visualElement;
+					if (ve) t.held = applyHold(ve, cue.sprite.element, cue.hold.values);
+				} else if (!inside && t.started) {
+					t.started = false;
+					const ve = cue.sprite.node.visualElement;
+					if (ve && t.held) {
+						releaseHold(ve, cue.sprite.element, t.held);
+						t.held = void 0;
+					}
+				}
+				continue;
+			}
+			if (cue.kind === "wait") continue;
+			if (inside && !t.started) this.startTrack(t);
+			else if (inside && t.started && this.playing && !t.controls && !t.delivery && !t.loopAnimation && (cue.target || cue.flight)) this.startTrack(t);
+			else if (!inside && t.started && now < t.start) {
+				t.passed = false;
+				t.started = false;
+				flushKeyframeResolvers();
+				this.stopTrack(t);
+				t.delivery?.cancel();
+				t.delivery = void 0;
+				t.loopAnimation?.cancel();
+				t.loopAnimation = void 0;
+				if (t.origin) rewinds.push(t);
+			} else if (t.started && now >= t.end && !cue.loop && !this.playing) this.completeTrack(t);
+			else if (!t.started && !t.passed && now >= t.end && !cue.loop) this.jumpFinals(t);
+			if (t.started && !this.playing && now >= t.start) {
+				if (t.delivery) {
+					t.delivery.pause();
+					t.delivery.seek(now - t.start);
+				} else if (t.loopAnimation) {
+					t.loopAnimation.pause();
+					const cycle = t.end - t.start;
+					t.loopAnimation.currentTime = cycle ? (now - t.start + (t.loopOffset ?? 0)) % cycle : 0;
+				} else if (cue.target || cue.flight) {
+					if (t.controls) {
+						flushKeyframeResolvers();
+						this.stopTrack(t);
+					}
+					this.sampleStill(t, now);
+				}
+			}
+		}
+		if (shot) {
+			const was = this.camera3d;
+			if (was.yaw !== shot.yaw || was.pitch !== shot.pitch || was.dolly !== shot.dolly || was.x !== shot.x || was.y !== shot.y || was.look?.x !== shot.look?.x || was.look?.y !== shot.look?.y || was.look?.z !== shot.look?.z) {
+				this.camera3d = shot;
+				this.options.onCamera3D?.({ ...shot });
+			}
+		}
+		this.rewind(rewinds, now);
+		this.driveAttachments(now);
+		this.foldPerforms(limit);
+	}
+	/** perform tracks whose commands the host currently holds (see foldPerforms) */
+	performed = /* @__PURE__ */ new Set();
+	/** dispatches queued for after the render pass, in fold order */
+	pendingPerforms = [];
+	performFlushBooked = false;
+	/**
+	* The command fold (§C4): the set of Perform cues at or before the
+	* clock IS the commanded state. Every evaluate — a play tick and a seek
+	* alike — re-derives the eligible set; growth dispatches the new
+	* commands in time order, and any shrink (a backward seek) resets the
+	* host first and replays the whole remaining prefix. Commands are
+	* idempotent statements of state by contract (`lamp.on`, never a
+	* toggle), which is exactly what makes the replay a re-derivation.
+	*
+	* Dispatches are DEFERRED past the render pass: the constructor's first
+	* evaluate runs while Glimmer may still be rendering, and a command
+	* exists to mutate application state. A reset collapses the queue — the
+	* dropped dispatches were never seen, and the replay that follows
+	* restates everything still standing.
+	*/
+	foldPerforms(limit) {
+		if (!this.options.onPerform && !this.options.onPerformReset) return;
+		const now = this.master;
+		const eligible = this.tracks.filter((t) => t.cue.perform && now >= t.start && t.start < limit).sort((a, b) => a.start - b.start);
+		const held = new Set(eligible);
+		if ([...this.performed].some((t) => !held.has(t))) {
+			this.performed.clear();
+			this.pendingPerforms.length = 0;
+			this.pendingPerforms.push("reset");
+		}
+		for (const t of eligible) {
+			if (this.performed.has(t)) continue;
+			this.performed.add(t);
+			const p = t.cue.perform;
+			this.pendingPerforms.push({
+				action: p.action,
+				payload: p.payload,
+				target: p.target,
+				time: t.start / this.scale / 1e3
+			});
+		}
+		if (this.pendingPerforms.length && !this.performFlushBooked) {
+			this.performFlushBooked = true;
+			frame.postRender(() => {
+				this.performFlushBooked = false;
+				const queue = this.pendingPerforms;
+				this.pendingPerforms = [];
+				for (const item of queue) if (item === "reset") this.options.onPerformReset?.();
+				else this.options.onPerform?.(item);
+			});
+		}
+	}
+	/**
+	* Stand rewound tracks back on their origins — the part of a backward
+	* seek that must be ORDERED. A sprite with sequential cues has one
+	* origin per cue, each equal to the previous cue's landing; restored
+	* in track order they clobber forward and the sprite ends up standing
+	* on its LAST future cue's origin (the Playhead demo's hand parked on
+	* 'place' after a scrub to zero; its receipt refusing to dismiss). So:
+	* latest-first, which leaves the EARLIEST future cue's origin — the
+	* value the timeline actually holds at `now` — standing; and a key
+	* that any track AT or BEFORE `now` writes is not touched at all,
+	* because that track's own sample or landing is the answer.
+	*/
+	rewind(rewinds, now) {
+		rewinds.sort((a, b) => b.start - a.start);
+		for (const t of rewinds) {
+			const ve = t.cue.sprite.node.visualElement;
+			if (!ve || !t.origin) continue;
+			let wrote = false;
+			for (const key in t.origin) if (!this.tracks.some((s) => s !== t && s.start <= now && s.cue.target !== void 0 && key in s.cue.target && s.cue.sprite.node.visualElement === ve)) {
+				ve.getValue(key, t.origin[key]).jump(t.origin[key]);
+				wrote = true;
+			}
+			if (wrote) ve.render();
+		}
+	}
+	/** the eased progress of a plain clock-driven track */
+	flightlessProgress(t, ms) {
+		if (this.reduced) return ms > 0 ? 1 : 0;
+		const span = t.end - t.start;
+		const raw = span > 0 ? Math.min(1, Math.max(0, ms / span)) : 1;
+		return easingDefinitionToFunction("easeInOut")(raw);
+	}
+	/**
+	* The orbit pose in force. Public for the same reason `camera` is: it is
+	* hand-off state, and a replacement run must continue from where this
+	* one left the shot rather than snapping back to the framing.
+	*/
+	camera3d;
+	initial3d;
+	camera;
+	/**
+	* The aim point P in force, local px. With transform-origin pinned at
+	* 0 0, the applied transform is translate(x + (1−z)·P) scale(z) — the
+	* frame's centre cancels out of the algebra entirely, so neither a
+	* board that reflows mid-cue nor a stage that changes height between
+	* cues can move the picture: the formula reads no live DOM at all.
+	* z = 1 is the identity for any P. Public because it is hand-off state:
+	* the next run lerps from the point THIS run left aimed, exactly as it
+	* inherits the camera.
+	*/
+	cameraAim = null;
+	/**
+	* The absolute pose a camera cue lands on, resolved against the pose it
+	* starts from. Absolute fields pass through; missing fields hold; a
+	* relative cue (Pan / SlowZoom) offsets and multiplies the pose in
+	* force — which is why resolution happens AT START (live) or during the
+	* prefix fold (reconstruction), never at compile.
+	*/
+	static resolveCameraTo(cue, from) {
+		const { by, to } = cue;
+		return {
+			x: by?.x !== void 0 ? from.x + by.x : to.x ?? from.x,
+			y: by?.y !== void 0 ? from.y + by.y : to.y ?? from.y,
+			zoom: by?.zoom !== void 0 ? from.zoom * by.zoom : to.zoom ?? from.zoom
+		};
+	}
+	cameraProgress(t, ms) {
+		if (this.reduced) return ms > 0 ? 1 : 0;
+		const span = t.end - t.start;
+		const raw = span > 0 ? Math.min(1, Math.max(0, ms / span)) : 1;
+		const transition = t.cue.transition;
+		if (isSpring(transition)) return spring({
+			keyframes: [0, 100],
+			...transition ?? {}
+		}).next(ms / this.scale).value / 100;
+		return easingDefinitionToFunction(transition?.ease ?? "easeInOut")(raw);
+	}
+	/**
+	* The camera and aim this run inherited, frozen at construction — the
+	* fold origin every reconstruction starts from. Public because a
+	* replacement run that re-executes the SAME score must inherit this
+	* origin, not the pose in force: the pose in force is what the score's
+	* prefix already produced, and folding the prefix from it applies every
+	* relative cue twice (the world-dock law).
+	*/
+	initialCamera;
+	initialAim;
+	/**
+	* Rebuild the camera fold from the score prefix before a seek's still
+	* (packages/choreo-gallery/realm/design/external-clock-camera-seek-handoff.md). Forward playback folds
+	* each camera cue's landing into the run's cumulative camera as the
+	* clock crosses it — but a random-access seek can jump clean over a
+	* window, and a cue that never starts never folds: the clock reads `t`
+	* while the picture holds an earlier shot. So every camera track's
+	* bookkeeping (started, cameraFrom, aimFrom/aimTo, cameraP) is
+	* re-derived here in timeline order from the run's initial camera;
+	* evaluate() then recomputes exactly the numbers forward playback would
+	* have produced, and play-after-scrub resumes from them. Pure
+	* arithmetic over frozen numbers, like the rest of the camera: no DOM
+	* is read, so backward and repeated seeks agree to the pixel.
+	*/
+	reconstructCameraAt(limit) {
+		const cams = this.tracks.filter((t) => t.cue.camera);
+		if (!cams.length) return;
+		const now = this.master;
+		cams.sort((a, b) => a.start - b.start);
+		const state = { ...this.initialCamera };
+		let aim = this.initialAim ? { ...this.initialAim } : null;
+		for (const t of cams) {
+			if (!(now >= t.start && t.start < limit)) {
+				t.started = false;
+				t.passed = false;
+				t.cameraP = 0;
+				t.cameraTo = void 0;
+				t.aimFrom = aim ?? void 0;
+				t.aimTo = aim ?? void 0;
+				t.cameraAnimation?.cancel();
+				t.cameraAnimation = void 0;
+				continue;
+			}
+			const cue = t.cue.camera;
+			const aimTo = cue.origin ?? aim ?? cue.centre ?? {
+				x: 0,
+				y: 0
+			};
+			t.started = true;
+			t.passed = false;
+			t.cameraFrom = { ...state };
+			t.cameraTo = ChoreoRun.resolveCameraTo(cue, t.cameraFrom);
+			t.aimFrom = aim ?? aimTo;
+			t.aimTo = aimTo;
+			aim = aimTo;
+			if (now >= t.end) {
+				state.x = t.cameraTo.x;
+				state.y = t.cameraTo.y;
+				state.zoom = t.cameraTo.zoom;
+				t.cameraP = 1;
+				t.cameraAnimation?.cancel();
+				t.cameraAnimation = void 0;
+			}
+		}
+		this.camera = state;
+		this.cameraAim = aim;
+		if (!cams.some((t) => t.started)) this.applyCamera(cams[0]);
+	}
+	/**
+	* The damped counter-scale (§6.4): steady sprites scale with the host but
+	* not 1:1 — pow(z, .30) zoomed out so they stay readable, pow(z, .70)
+	* zoomed in so they don't feel stuck, clamped to what the eye tolerates.
+	*/
+	static damped(zoom) {
+		return Math.min(1.8, Math.max(.85, Math.pow(zoom, zoom < 1 ? .3 : .7))) / zoom;
+	}
+	/**
+	* The frame's APPLIED transform for a camera state at aim progress `p`.
+	*
+	* Transform-origin is pinned at 0 0, so the applied transform is
+	* translate(x + (1−z)·P) scale(z) with P the lerped aim point — pure
+	* arithmetic over frozen numbers. Nothing here reads the DOM, so a board
+	* that reflows mid-cue cannot move the camera, and every boundary
+	* (landing, re-aim, next run) agrees to the pixel. At z = 1 the aim term
+	* vanishes: an unpanned camera is EXACTLY the identity.
+	*/
+	appliedCamera(t, state, p) {
+		const from = t.aimFrom ?? t.aimTo ?? {
+			x: 0,
+			y: 0
+		};
+		const to = t.aimTo ?? from;
+		const aim = {
+			x: from.x + (to.x - from.x) * p,
+			y: from.y + (to.y - from.y) * p
+		};
+		return {
+			x: state.x + (1 - state.zoom) * aim.x,
+			y: state.y + (1 - state.zoom) * aim.y,
+			zoom: state.zoom
+		};
+	}
+	static cameraCss(a) {
+		return a.zoom === 1 && a.x === 0 && a.y === 0 ? "" : `translate(${a.x}px, ${a.y}px) scale(${a.zoom})`;
+	}
+	/**
+	* Fly the region's frame on the platform: two transform keyframes and the
+	* eased clock pre-sampled into a linear() easing. The biggest layer in the
+	* region composites off the main thread for the whole move.
+	*/
+	startCameraAnimation(t, now) {
+		const host = this.options.cameraFrame;
+		const from = t.cameraFrom;
+		const cue = t.cue.camera;
+		if (!host || !from || !cue) return;
+		const final = t.cameraTo ?? ChoreoRun.resolveCameraTo(cue, from);
+		const span = Math.max(1, t.end - t.start);
+		const anim = host.animate([{ transform: ChoreoRun.cameraCss(this.appliedCamera(t, from, 0)) || "none" }, { transform: ChoreoRun.cameraCss(this.appliedCamera(t, final, 1)) || "none" }], {
+			duration: span,
+			easing: generateLinearEasing((p) => this.cameraProgress(t, p * span), span),
+			fill: "both"
+		});
+		anim.playbackRate = this.rate;
+		anim.currentTime = Math.max(0, now - t.start);
+		t.cameraAnimation = anim;
+	}
+	/**
+	* Retire the frame's platform animation and hand the picture back to
+	* inline style, written from the shadow state — so a cancel mid-zoom
+	* freezes exactly where the eye was, and a landing holds its final.
+	*/
+	dropCameraAnimation(t) {
+		if (!t.cameraAnimation) return;
+		t.cameraAnimation.cancel();
+		t.cameraAnimation = void 0;
+		this.applyCamera(t);
+	}
+	applyCamera(t) {
+		const frame = this.options.cameraFrame;
+		if (!frame) return;
+		const { zoom } = this.camera;
+		frame.style.transformOrigin = "0px 0px";
+		if (!t.cameraAnimation) frame.style.transform = ChoreoRun.cameraCss(this.appliedCamera(t, this.camera, t.cameraP ?? 1));
+		for (const sprite of t.cue.camera?.steady ?? []) {
+			const ve = sprite.node.visualElement;
+			if (ve) {
+				const counter = ChoreoRun.damped(zoom);
+				ve.getValue("scale", counter).set(counter);
+			}
+		}
+	}
+	tetherDrawScheduled = false;
+	scheduleTetherDraw() {
+		if (this.tetherDrawScheduled) return;
+		this.tetherDrawScheduled = true;
+		frame.postRender(() => {
+			this.tetherDrawScheduled = false;
+			for (const t of this.tracks) if (t.started && t.wire) this.drawTether(t);
+		});
+	}
+	/**
+	* One frame of a derived value (§4.10): compose the context from the
+	* pass's measurements, hand it to the author's function, write what
+	* comes back.
+	*
+	* Nothing here touches the DOM — that is the design, not an
+	* optimisation (packages/choreo-gallery/realm/docs/postmortem-follow.md). The resting boxes were
+	* measured by the pass with every moved value released, and a source's
+	* `now` is its resting box composed with the motion values driving it
+	* this frame: JS-side numbers, not a measurement. So a follower is pure
+	* BY CONSTRUCTION — there is no live box in reach, it cannot read back
+	* its own output, and it cannot force a style recalculation in the
+	* middle of a move. It is also correct under INTERRUPTION for free: a
+	* replacement run's pass re-measures, so a run born mid-flight computes
+	* from rests that are right immediately, with no "last frame" to
+	* disagree with.
+	*
+	* `set`, not an animation: a derived value IS the frame, so there is
+	* nothing to interpolate toward and nothing the compositor could be
+	* given — this is the main-thread cost the step charges, and the reason
+	* it is the same cost `c.Tether` already pays.
+	*/
+	drive(t, now) {
+		const derive = t.cue.derive;
+		const ve = t.cue.sprite.node.visualElement;
+		if (!derive || !ve) return;
+		const sources = derive.sources.map(({ from, sprite, to }) => {
+			const sv = sprite.node.visualElement;
+			const num = (key) => {
+				const value = sv?.getValue(key)?.get();
+				return typeof value === "number" ? value : void 0;
+			};
+			const sx = num("scaleX") ?? num("scale") ?? 1;
+			const sy = num("scaleY") ?? num("scale") ?? 1;
+			const width = to.width * sx;
+			const height = to.height * sy;
+			return {
+				from,
+				now: {
+					height,
+					width,
+					x: to.x + (num("x") ?? 0) + (to.width - width) / 2,
+					y: to.y + (num("y") ?? 0) + (to.height - height) / 2
+				},
+				to
+			};
+		});
+		const span = t.end - t.start;
+		const values = derive.read({
+			camera: { ...this.camera },
+			p: span > 0 ? Math.max(0, Math.min(1, (now - t.start) / span)) : 1,
+			rest: { ...derive.restBox },
+			sources,
+			t: now / 1e3
+		});
+		for (const [key, value] of Object.entries(values)) ve.getValue(key, value).set(value);
+		ve.render();
+	}
+	/** the window closed (or was scrubbed out of): put the declared rest back */
+	restDerived(t) {
+		const rest = t.cue.derive?.rest;
+		const ve = t.cue.sprite.node.visualElement;
+		if (!rest || !ve) return;
+		for (const [key, value] of Object.entries(rest)) ve.getValue(key, value).jump(value);
+		ve.render();
+	}
+	drawTether(t) {
+		const layer = this.options.tetherLayer;
+		const tether = t.cue.tether;
+		if (!layer || !tether || !t.wire) return;
+		const inverse = layer.getScreenCTM()?.inverse();
+		const box = layer.getBoundingClientRect();
+		const toLocal = (clientX, clientY) => {
+			if (!inverse) return {
+				x: clientX - box.left,
+				y: clientY - box.top
+			};
+			const p = new DOMPoint(clientX, clientY).matrixTransform(inverse);
+			return {
+				x: p.x,
+				y: p.y
+			};
+		};
+		const rectOf = (sprite) => {
+			const el = sprite?.element;
+			if (!el?.isConnected) return null;
+			const r = el.getBoundingClientRect();
+			const tl = toLocal(r.left, r.top);
+			const br = toLocal(r.right, r.bottom);
+			return {
+				height: br.y - tl.y,
+				width: br.x - tl.x,
+				x: tl.x,
+				y: tl.y
+			};
+		};
+		const a = rectOf(tether.from);
+		const b = rectOf(tether.to);
+		if (a && b) t.wire.setAttribute("d", tether.path(a, b));
+	}
+	/**
+	* The scale between the layer's own pixels and the screen's, per axis.
+	*
+	* A promotion reads client rects and writes LOCAL pixels, and every
+	* transform above the region — a camera zoom, a page crossing carrying the
+	* whole scene, any ancestor with a scale on it — sits between the two. Read
+	* off the layer itself: its rect is what the screen shows, its offset size
+	* is what its own coordinate system calls that. Dividing by the camera zoom
+	* alone would catch the region's own transform and miss everything outside
+	* it, which is the double-scale the tether draw already dodges by mapping
+	* through the screen CTM.
+	*/
+	static layerScale(el, box) {
+		return {
+			x: el.offsetWidth ? box.width / el.offsetWidth : 1,
+			y: el.offsetHeight ? box.height / el.offsetHeight : 1
+		};
+	}
+	promote(t) {
+		const layer = this.options.raisedLayer;
+		const el = t.cue.sprite.element;
+		if (!layer || !el.isConnected || t.perch) return;
+		const box = el.getBoundingClientRect();
+		const layerBox = layer.getBoundingClientRect();
+		const s = ChoreoRun.layerScale(layer, layerBox);
+		const width = box.width / s.x;
+		const height = box.height / s.y;
+		const placeholder = document.createElement(el.tagName);
+		placeholder.setAttribute("aria-hidden", "true");
+		placeholder.style.cssText = `visibility:hidden;width:${width}px;height:${height}px;margin:0;flex:none`;
+		const prior = el.style.cssText;
+		el.parentNode?.insertBefore(placeholder, el);
+		layer.appendChild(el);
+		el.style.position = "absolute";
+		el.style.left = `${(box.left - layerBox.left) / s.x}px`;
+		el.style.top = `${(box.top - layerBox.top) / s.y}px`;
+		el.style.width = `${width}px`;
+		el.style.height = `${height}px`;
+		el.style.margin = "0";
+		if (t.cue.raise?.shadow) el.style.filter = "drop-shadow(0 18px 24px rgba(0,0,0,0.35))";
+		t.perch = {
+			placeholder,
+			prior
+		};
+	}
+	restore(t) {
+		const el = t.cue.sprite.element;
+		const perch = t.perch;
+		if (!perch) return;
+		t.perch = void 0;
+		perch.placeholder.parentNode?.replaceChild(el, perch.placeholder);
+		el.style.cssText = perch.prior;
+		t.cue.sprite.node.visualElement?.scheduleRender();
+	}
+	startScroll(t) {
+		const el = t.cue.sprite.element;
+		let container = el.parentElement;
+		while (container) {
+			const cs = getComputedStyle(container);
+			if (/(auto|scroll)/.test(cs.overflowY + cs.overflowX)) break;
+			container = container.parentElement;
+		}
+		if (!container) return;
+		const box = el.getBoundingClientRect();
+		const cBox = container.getBoundingClientRect();
+		const s = ChoreoRun.layerScale(container, cBox);
+		const align = t.cue.scroll.align;
+		const offsetY = (box.top - cBox.top) / s.y + container.scrollTop;
+		const offsetX = (box.left - cBox.left) / s.x + container.scrollLeft;
+		const factor = align === "center" ? .5 : align === "end" ? 1 : 0;
+		const to = {
+			left: Math.max(0, offsetX - (container.clientWidth - box.width / s.x) * factor),
+			top: Math.max(0, offsetY - (container.clientHeight - box.height / s.y) * factor)
+		};
+		const onWheel = () => this.stopScroll(t, false);
+		container.addEventListener("wheel", onWheel, { passive: true });
+		container.addEventListener("touchmove", onWheel, { passive: true });
+		t.scrolling = {
+			cancelListener: () => {
+				container.removeEventListener("wheel", onWheel);
+				container.removeEventListener("touchmove", onWheel);
+			},
+			container,
+			from: {
+				left: container.scrollLeft,
+				top: container.scrollTop
+			},
+			to
+		};
+	}
+	stopScroll(t, rewind) {
+		const s = t.scrolling;
+		if (!s) return;
+		t.scrolling = void 0;
+		s.cancelListener();
+		if (rewind) {
+			s.container.scrollTop = s.from.top;
+			s.container.scrollLeft = s.from.left;
+		}
+	}
+	/** stop a track's animations at the value level — an async animation
+	*  cancelled before it resolves stays 'idle' forever if only the controls
+	*  are stopped, and its value then reads as animating for good */
+	stopTrack(t) {
+		t.controls?.forEach((c) => c.stop());
+		t.controls = void 0;
+		t.platform?.forEach((a) => a.cancel());
+		t.platform = void 0;
+		const ve = t.cue.sprite.node.visualElement;
+		if (ve && t.cue.target) for (const key in t.cue.target) ve.getValue(key)?.stop();
+	}
+	/** land a cue's end values without ever having played it */
+	jumpFinals(t) {
+		const { cue } = t;
+		const ve = cue.sprite.node.visualElement;
+		if (!ve || !cue.target && !cue.flight) return;
+		if (cue.flight) {
+			this.applyFlight(t, 1);
+			ve.render();
+			if (!cue.target) {
+				t.passed = true;
+				return;
+			}
+		}
+		if (!t.origin) {
+			const origin = {};
+			for (const key in cue.target) {
+				const value = cue.target[key];
+				if (Array.isArray(value)) origin[key] = value[0];
+				else {
+					const held = ve.getValue(key)?.get();
+					origin[key] = held !== void 0 ? held : getComputedStyle(cue.sprite.element).getPropertyValue(dash(key)) || 0;
+				}
+			}
+			t.origin = origin;
+		}
+		t.passed = true;
+		for (const key in cue.target) {
+			const raw = cue.target[key];
+			const end = Array.isArray(raw) ? raw[raw.length - 1] : raw;
+			ve.getValue(key, end).jump(end);
+		}
+		ve.render();
+	}
+	startTrack(t) {
+		const { cue } = t;
+		const ve = cue.sprite.node.visualElement;
+		if (!ve) return;
+		t.started = true;
+		t.passed = false;
+		if (cue.target && !t.origin) {
+			const origin = {};
+			for (const key in cue.target) {
+				const value = cue.target[key];
+				if (Array.isArray(value)) origin[key] = value[0];
+				else {
+					const held = ve.getValue(key)?.get();
+					const latest = ve.latestValues[key];
+					origin[key] = held !== void 0 ? held : latest !== void 0 ? latest : getComputedStyle(cue.sprite.element).getPropertyValue(dash(key)) || 0;
+				}
+			}
+			t.origin = origin;
+		}
+		if (cue.delivery) {
+			for (const key in cue.target) {
+				const raw = cue.target[key];
+				if (Array.isArray(raw)) {
+					const end = raw[raw.length - 1];
+					ve.getValue(key, end).jump(end);
+				}
+			}
+			ve.render();
+			t.delivery = deliver(cue, this.scale, this.reduced);
+			if (!this.playing) t.delivery.pause();
+			return;
+		}
+		if (cue.loop) {
+			const target = this.reduced ? withoutMovement(cue.target) : cue.target;
+			const el = cue.sprite.element;
+			const cycle = t.end - t.start;
+			const phase = this.options.loops?.get(cue.sprite.node)?.get(loopKey(cue));
+			t.loopOffset = phase === void 0 ? void 0 : phase * cycle;
+			const times = cue.transition?.times;
+			const segmentEase = cssEasing(cue.transition?.ease, cycle);
+			t.loopAnimation = el.animate(keyframesOf(target ?? {}, Object.keys(target ?? {}).length ? times : void 0, segmentEase), {
+				duration: Math.max(1, cycle),
+				easing: times ? "linear" : segmentEase,
+				iterations: Infinity
+			});
+			t.loopAnimation.currentTime = (Math.max(0, this.master - t.start) + (t.loopOffset ?? 0)) % Math.max(1, cycle);
+			t.loopAnimation.playbackRate = this.rate;
+			if (!this.playing) t.loopAnimation.pause();
+			return;
+		}
+		if (cue.flight) {
+			this.startFlight(t);
+			return;
+		}
+		if (!cue.target) return;
+		if (!this.playing) {
+			this.sampleStill(t, this.master);
+			return;
+		}
+		const transition = carryVelocity(scaleTransition({
+			...cue.transition,
+			reduceMotion: this.reduced
+		}, this.scale), cue, this.options.inherit);
+		t.controls = animateTarget(ve, {
+			...cue.target,
+			transition
+		});
+		for (const c of t.controls) c.speed = this.rate;
+	}
+	/** put the sprite at progress `p` of its sampled flight path (§4.4) */
+	applyFlight(t, p) {
+		const { cue } = t;
+		const ve = cue.sprite.node.visualElement;
+		const flight = cue.flight;
+		if (!ve || !flight) return;
+		const pts = flight.points;
+		const at = Math.min(pts.length - 1 - 1e-9, Math.max(0, p) * (pts.length - 1));
+		const index = Math.floor(at);
+		const local = at - index;
+		const a = pts[index];
+		const b = pts[Math.min(index + 1, pts.length - 1)];
+		const x = a.x + (b.x - a.x) * local - flight.rest.x;
+		const y = a.y + (b.y - a.y) * local - flight.rest.y;
+		ve.getValue("x", x).set(x);
+		ve.getValue("y", y).set(y);
+		if (flight.rotate !== void 0) {
+			const angle = Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI + (typeof flight.rotate === "number" ? flight.rotate : 0);
+			ve.getValue("rotate", angle).set(angle);
+		}
+	}
+	/** the eased progress a flight sits at, `ms` into its window */
+	flightProgress(t, ms) {
+		if (this.reduced) return ms > 0 ? 1 : 0;
+		const span = t.end - t.start;
+		const raw = span > 0 ? Math.min(1, Math.max(0, ms / span)) : 1;
+		const transition = t.cue.transition;
+		if (isSpring(transition)) {
+			const pts = t.cue.flight.points;
+			const end = pts[pts.length - 1];
+			const distance = Math.hypot(end.x, end.y) || 1;
+			return spring({
+				keyframes: [0, distance],
+				...transition ?? {}
+			}).next(ms / this.scale).value / distance;
+		}
+		return easingDefinitionToFunction(transition?.ease ?? "easeInOut")(raw);
+	}
+	/**
+	* The sampled path as platform keyframes: each point becomes a transform,
+	* uniformly spaced (the points were sampled uniformly in progress), and
+	* the eased clock rides the animation's easing instead of per-frame JS.
+	*/
+	flightKeyframes(t) {
+		const flight = t.cue.flight;
+		const pts = flight.points;
+		const frames = [];
+		for (let i = 0; i < pts.length; i++) {
+			const p = pts[i];
+			let transform = `translate(${p.x - flight.rest.x}px, ${p.y - flight.rest.y}px)`;
+			if (flight.rotate !== void 0) {
+				const a = pts[Math.max(0, i - 1)];
+				const b = pts[Math.min(pts.length - 1, i + 1)];
+				const angle = Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI + (typeof flight.rotate === "number" ? flight.rotate : 0);
+				transform += ` rotate(${angle}deg)`;
+			}
+			frames.push({ transform });
+		}
+		return frames;
+	}
+	startFlight(t) {
+		const { cue } = t;
+		const ve = cue.sprite.node.visualElement;
+		if (!ve) return;
+		if (!this.playing) {
+			this.sampleStill(t, this.master);
+			return;
+		}
+		const span = Math.max(1, t.end - t.start);
+		const controls = [];
+		const anim = cue.sprite.element.animate(this.flightKeyframes(t), {
+			duration: span,
+			easing: generateLinearEasing((p) => this.flightProgress(t, p * span), span),
+			fill: "both"
+		});
+		anim.playbackRate = this.rate;
+		anim.currentTime = Math.min(span, Math.max(0, this.master - t.start));
+		(t.platform ??= []).push(anim);
+		controls.push(platformControls(anim));
+		if (cue.target && Object.keys(cue.target).length) {
+			const transition = scaleTransition({
+				...cue.transition,
+				onUpdate: noop
+			}, this.scale);
+			controls.push(...animateTarget(ve, {
+				...cue.target,
+				transition
+			}));
+		}
+		for (const c of controls) c.speed = this.rate;
+		t.controls = controls;
+	}
+	/** compute one still frame of a cue and jump the values onto the element */
+	sampleStill(t, now) {
+		const { cue } = t;
+		const ve = cue.sprite.node.visualElement;
+		if (!ve || !cue.target && !cue.flight) return;
+		if (cue.flight) {
+			this.applyFlight(t, this.flightProgress(t, now - t.start));
+			ve.render();
+			if (!cue.target) return;
+		}
+		const span = t.end - t.start;
+		const p = span > 0 ? Math.min(1, Math.max(0, (now - t.start) / span)) : 1;
+		const transition = cue.transition;
+		const sprung = isSpring(transition);
+		const ease = sprung ? null : easingDefinitionToFunction(transition?.ease ?? "easeInOut");
+		for (const key in cue.target) {
+			const raw = cue.target[key];
+			const frames = Array.isArray(raw) ? raw : [t.origin?.[key] ?? 0, raw];
+			const numeric = frames.map((f) => parseFloat(String(f)));
+			if (numeric.some((n) => Number.isNaN(n))) {
+				const segments = frames.length - 1;
+				if (segments < 1) {
+					ve.getValue(key, frames[0]).jump(frames[0]);
+					continue;
+				}
+				let at;
+				if (sprung) at = spring({
+					keyframes: [0, segments],
+					...transition ?? {}
+				}).next(now - t.start).value;
+				else at = (ease ? ease(p) : p) * segments;
+				at = Math.min(segments - 1e-9, Math.max(0, at));
+				const index = Math.floor(at);
+				const value = mix(frames[index], frames[index + 1])(at - index);
+				ve.getValue(key, value).jump(value);
+				continue;
+			}
+			let value;
+			if (sprung) value = spring({
+				keyframes: [numeric[0], numeric[numeric.length - 1]],
+				...transition ?? {}
+			}).next(now - t.start).value;
+			else {
+				const times = Array.isArray(raw) ? transition?.times : void 0;
+				const eased = ease ? ease(p) : p;
+				const segments = numeric.length - 1;
+				const at = Math.min(segments - 1e-9, eased * segments);
+				const index = times ? p >= 1 ? segments - 1 : Math.max(0, times.findIndex((time) => time > p) - 1) : Math.max(0, Math.floor(at));
+				const progress = times ? p >= 1 ? 1 : (p - times[index]) / (times[index + 1] - times[index]) : at - index;
+				const local = times && ease ? ease(progress) : progress;
+				value = numeric[index] + (numeric[index + 1] - numeric[index]) * local;
+			}
+			ve.getValue(key, value).jump(value);
+		}
+		ve.render();
+	}
+	completeTrack(t) {
+		const { cue } = t;
+		if (t.passed) return;
+		t.passed = true;
+		t.started = false;
+		flushKeyframeResolvers();
+		this.stopTrack(t);
+		if (t.delivery) {
+			t.delivery.complete();
+			t.delivery = void 0;
+		}
+		const ve = cue.sprite.node.visualElement;
+		if (ve && cue.flight) {
+			this.applyFlight(t, 1);
+			ve.render();
+		}
+		if (ve && cue.target) {
+			for (const key in cue.target) {
+				const raw = cue.target[key];
+				const end = Array.isArray(raw) ? raw[raw.length - 1] : raw;
+				ve.getValue(key, end).jump(end);
+			}
+			ve.render();
+		}
+	}
+	pinStarts() {
+		const pinned = /* @__PURE__ */ new Set();
+		const rendered = /* @__PURE__ */ new Set();
+		for (const t of [...this.tracks].sort((a, b) => a.start - b.start)) {
+			const cue = t.cue;
+			const ve = cue.sprite.node.visualElement;
+			if (!ve || cue.loop) continue;
+			if (cue.flight) {
+				this.movedValues.push({
+					key: "x",
+					ve
+				}, {
+					key: "y",
+					ve
+				});
+				this.owned.push({
+					el: cue.sprite.element,
+					key: "x",
+					ve
+				}, {
+					el: cue.sprite.element,
+					key: "y",
+					ve
+				});
+				if (cue.flight.rotate !== void 0) this.movedValues.push({
+					key: "rotate",
+					ve
+				});
+				this.applyFlight({ ...t }, 0);
+				rendered.add(ve);
+			}
+			if (!cue.target) continue;
+			for (const key in cue.target) {
+				const value = cue.target[key];
+				if (!Array.isArray(value) || value[0] === void 0) continue;
+				const seen = `${cue.sprite.node.layoutKey}:${key}`;
+				if (pinned.has(seen)) continue;
+				pinned.add(seen);
+				this.owned.push({
+					el: cue.sprite.element,
+					key,
+					ve
+				});
+				if (cue.kind === "move") if (key in SIZES) {
+					if (!ve.hasValue(key)) this.borrowedValues.push({
+						el: cue.sprite.element,
+						key,
+						prior: cue.sprite.element.style.getPropertyValue(dash(key)),
+						ve
+					});
+				} else this.movedValues.push({
+					key,
+					rest: key.startsWith("scale") ? 1 : key === "clipPath" ? "none" : 0,
+					ve
+				});
+				else if (cue.borrow && !ve.hasValue(key)) this.borrowedValues.push({
+					el: cue.sprite.element,
+					key,
+					prior: cue.sprite.element.style.getPropertyValue(dash(key)),
+					ve
+				});
+				ve.getValue(key, value[0]).jump(value[0]);
+				rendered.add(ve);
+			}
+		}
+		rendered.forEach((ve) => ve.render());
+	}
+	sampleVelocities() {
+		for (const { ve, el, key } of this.owned) {
+			let byKey = this.velocities.get(el);
+			if (byKey?.has(key)) continue;
+			const velocity = ve.getValue(key)?.getVelocity();
+			if (!velocity) continue;
+			if (!byKey) this.velocities.set(el, byKey = /* @__PURE__ */ new Map());
+			byKey.set(key, velocity);
+		}
+	}
+	releaseForMeasure() {
+		this.sampleVelocities();
+		for (const t of this.tracks) {
+			t.platform?.forEach((a) => a.cancel());
+			t.platform = void 0;
+			this.dropCameraAnimation(t);
+		}
+		const touched = /* @__PURE__ */ new Set();
+		this.retired = {
+			borrowed: [],
+			moved: []
+		};
+		for (const { ve, el, key, prior } of this.borrowedValues.splice(0)) {
+			this.retired.borrowed.push({
+				el,
+				key,
+				prior,
+				value: ve.getValue(key)?.get(),
+				ve
+			});
+			ve.removeValue(key);
+			if (prior) el.style.setProperty(dash(key), prior);
+			else el.style.removeProperty(dash(key));
+			touched.add(ve);
+		}
+		for (const { ve, key, rest } of this.movedValues.splice(0)) {
+			this.retired.moved.push({
+				key,
+				rest,
+				value: ve.getValue(key)?.get(),
+				ve
+			});
+			ve.getValue(key)?.jump(rest ?? 0);
+			touched.add(ve);
+		}
+		touched.forEach((ve) => ve.render());
+	}
+	/**
+	* A pass measured this run's world at rest and then decided to KEEP the
+	* run — but the measurement itself was destructive: releaseForMeasure
+	* cancels platform animations, returns borrowed values, and jumps every
+	* moved value to rest, and a MotionValue.jump() STOPS the animation
+	* driving it. Left like that, a kept run keeps its clock and its landing
+	* but loses its picture: the flight freezes at rest until the finals
+	* land — which on a busy page (the gallery: neighbours re-pass the
+	* region every render) is every crossing, every time. So the keep path
+	* calls this: moved and borrowed values are stood back where they were,
+	* their bookkeeping is re-registered, every in-flight track's animation
+	* is retired so evaluate re-enters it — the machinery a scrub-then-play
+	* already uses — and the re-entered animations are seeked back onto the
+	* run's own clock, so a keep is invisible rather than a restart.
+	*/
+	reassert() {
+		const { borrowed, moved } = this.retired;
+		this.retired = {
+			borrowed: [],
+			moved: []
+		};
+		for (const { el, key, prior, value, ve } of borrowed) {
+			if (value !== void 0) ve.getValue(key, value).jump(value);
+			this.borrowedValues.push({
+				el,
+				key,
+				prior,
+				ve
+			});
+		}
+		for (const { key, rest, value, ve } of moved) {
+			if (value !== void 0) ve.getValue(key)?.jump(value);
+			this.movedValues.push({
+				key,
+				rest,
+				ve
+			});
+		}
+		if (!this.playing) return;
+		const now = this.master;
+		const restarted = [];
+		for (const t of this.tracks) if (t.started && !t.passed && now >= t.start && (now < t.end || t.cue.loop) && (t.cue.target || t.cue.flight)) {
+			flushKeyframeResolvers();
+			this.stopTrack(t);
+			restarted.push(t);
+		}
+		this.evaluate();
+		for (const t of restarted) if (!t.cue.flight) {
+			const at = Math.max(0, now - t.start) / 1e3;
+			t.controls?.forEach((c) => {
+				c.time = at;
+			});
+		}
+	}
+	cancel(keep) {
+		if (this.cancelled) return;
+		this.cancelled = true;
+		activeRuns.delete(this);
+		this.stopTicking();
+		clearTimeout(this.autoTimer);
+		this.pendingPerforms.length = 0;
+		this.options.onCamera?.({ ...this.camera });
+		flushKeyframeResolvers();
+		this.sampleVelocities();
+		for (const t of this.tracks) {
+			this.stopTrack(t);
+			t.delivery?.cancel();
+			t.loopAnimation?.cancel();
+			this.dropCameraAnimation(t);
+			this.restore(t);
+			this.stopScroll(t, false);
+			t.wire?.remove();
+			t.wire = void 0;
+			const ve = t.cue.sprite.node.visualElement;
+			if (t.held && ve) {
+				releaseHold(ve, t.cue.sprite.element, t.held);
+				t.held = void 0;
+			}
+		}
+		this.releaseForMeasure();
+		for (const sprite of [...this.pending]) if (keep?.has(sprite.node)) this.pending.delete(sprite);
+		else {
+			this.pending.delete(sprite);
+			this.options.onSpriteDone(sprite);
+		}
+		this.resolveFinished();
+	}
+};
+/** every live run, for the test helpers that drive gates and clocks */
+var activeRuns = /* @__PURE__ */ new Set();
+function execute(compiled, options) {
+	return new ChoreoRun(compiled, options);
+}
+//#endregion
+export { resetBeacons as C, measure as E, registerBeacon as S, isRendered as T, sameScore as _, choreoHostById as a, trackGestures as b, join as c, resetBarrier as d, setBeforeMeasure as f, fadeOn as g, continuation as h, choreoHostAt as i, leave as l, compile as m, execute as n, closestChoreo as o, setPassScheduler as p, resetRunWarnings as r, setChoreoHost as s, activeRuns as t, registerSettle as u, GESTURE as v, boundsOf as w, measureBeacons as x, resetGestures as y };