@cardstack/boxel-cli 0.9.0-unstable.5 → 0.9.0-unstable.6

package/bundled-test-harness/assets/{choreo-gallery-build-order-test-C6q9CDNY.js → choreo-gallery-build-order-test-7TpxKQd2.js}

@@ -14,7 +14,7 @@ import "./src-DKlevVIu.js";
 import { t as MotionModifier } from "./motion-CU0yC2Ky.js";
 import { t as Presence } from "./presence-BYtEBpVa.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest, r as frames, s as sleep } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, r as frames, s as sleep } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-build-order-test.gts
 /**
 * The Build Order demo: as a popLayout leaver, beside a noisy neighbour, and

package/bundled-test-harness/assets/{choreo-gallery-compositor-test-C-GwjEUw.js → choreo-gallery-compositor-test-BgMWB-xz.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-compositor-test.ts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 /** A run that records the transport ops the host performs on it. */

package/bundled-test-harness/assets/choreo-gallery-cover-test-uR-CNV8g.js

@@ -0,0 +1,205 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Lr as testRealmURL, Pr as testHostModeRealmURL } from "./runtime-common-0-Tvgtf6.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { t as HostModeService } from "./host-mode-service-CtK92ze8.js";
+import { M as waitUntil, a as find, d as click, i as findAll, k as visit, l as triggerEvent, o as waitFor } from "./dist-BGqriEf8.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, ct as setupApplicationTest, j as setupAcceptanceTestRealm, pt as setupAuthEndpoints, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-CJaQa5Mm.js";
+import { r as choreoGalleryRealmOf } from "./choreo-gallery-D8__QZCe.js";
+//#region tests/acceptance/choreo-gallery-cover-test.gts
+/**
+* A demo card opened from the Choreo gallery covers the gallery without
+* unmounting it: the stack item below in interact mode, the primary card
+* under the stack on a published site. The grid's stages rest while they
+* are covered — no loop runs, no endless animation plays — and carry on
+* from where they were when the demo closes.
+*/ var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+/**
+* Crossing first, so its tile is in view: its tape scrolls itself in a frame
+* loop for as long as the stage is on. Circle loop's score and Keyframes'
+* morph repeat forever, one as Web Animations a Choreo pass starts by script,
+* the other written by Motion frame by frame. Wires' tethers stand for as long
+* as its board does, so its run ticks and its rest wires are redrawn every
+* frame until resting pauses both.
+*/
+var DEMOS = [
+	"crossing",
+	"circle-loop",
+	"keyframes",
+	"wires",
+	"enter"
+];
+/** the module that runs the tape's loop */
+var TAPE = "/lib/xstress-live";
+var stageOf = (slug) => `[data-gallery-tile="${slug}"] .tile-stage`;
+var resting = (stage) => stage.classList.contains("is-resting");
+/** animations playing in any tile's stage */
+var runningInStages = () => findAll(".tile-stage").flatMap((stage) => stage.getAnimations({ subtree: true })).filter((animation) => animation.playState === "running").length;
+/**
+* Waits for every tile's stage to stop playing. A resting stage pauses what
+* it finds at once, and looks again within a second for effects a score
+* starts by script, so a tile whose score passes as the page opens over it
+* rests a moment later than the rest.
+*/
+var stagesSettled = () => waitUntil(() => runningInStages() === 0, { timeout: 2500 }).catch(() => void 0);
+/**
+* A click on a tile's title as a pointer makes it. The `click` helper also
+* focuses the link first, and focusing a link scrolls it into view, which in
+* the test's small container scrolls the tile being watched out of it.
+*/
+var openTile = (scope, slug) => triggerEvent(`${scope}[data-gallery-tile="${slug}"] .tile-title`, "click");
+var frames = (count) => new Promise((resolve) => {
+	let left = count;
+	let step = () => --left <= 0 ? resolve() : requestAnimationFrame(step);
+	requestAnimationFrame(step);
+});
+/**
+* How many frames a module's code asks for over a run of painted frames. A
+* running loop asks for every one; a stopped loop asks for none. (The tape's
+* own position is no measure: it moves under a pixel a frame, and at a device
+* pixel ratio of 1 the browser rounds that back to where it was.)
+*/
+async function framesAskedBy(module, count = 10) {
+	let asked = 0;
+	let original = window.requestAnimationFrame;
+	window.requestAnimationFrame = (callback) => {
+		if ((/* @__PURE__ */ new Error()).stack?.includes(module)) asked++;
+		return original.call(window, callback);
+	};
+	try {
+		await frames(count);
+	} finally {
+		window.requestAnimationFrame = original;
+	}
+	return asked;
+}
+/**
+* How many changes the tiles' DOM takes over a run of painted frames. A loop
+* Motion or Choreo runs by script writes styles and paths every frame; a grid
+* at rest writes nothing.
+*/
+async function tileWrites(count = 10) {
+	let writes = 0;
+	let observer = new MutationObserver((records) => {
+		writes += records.length;
+	});
+	for (let tile of findAll("[data-gallery-tile]")) observer.observe(tile, {
+		attributes: true,
+		characterData: true,
+		childList: true,
+		subtree: true
+	});
+	try {
+		await frames(count);
+	} finally {
+		observer.disconnect();
+	}
+	return writes;
+}
+(0, import_qunit.module)("Acceptance | Choreo gallery | covered by a demo", function() {
+	(0, import_qunit.module)("in interact mode", function(hooks) {
+		setupApplicationTest(hooks);
+		setupLocalIndexing(hooks);
+		setupOnSave(hooks);
+		let mockMatrixUtils = setupMockMatrix(hooks, {
+			loggedInAs: "@testuser:localhost",
+			activeRealms: [testRealmURL]
+		});
+		hooks.beforeEach(async function() {
+			mockMatrixUtils.createAndJoinRoom({
+				sender: "@testuser:localhost",
+				name: "room-test"
+			});
+			setupUserSubscription();
+			setupAuthEndpoints();
+			await setupAcceptanceTestRealm({
+				mockMatrixUtils,
+				contents: choreoGalleryRealmOf(DEMOS)
+			});
+		});
+		const gallery = `${testRealmURL}index`;
+		const demo = (slug) => `${testRealmURL}demos/${slug}`;
+		const stackCard = (index) => `[data-test-operator-mode-stack="0"] [data-test-stack-card-index="${index}"]`;
+		(0, import_qunit.test)("the grid’s stages rest under the demo, mounted, and wake when it closes", async function(assert) {
+			await visitOperatorMode({ stacks: [[{
+				id: gallery,
+				format: "isolated"
+			}]] });
+			await waitFor(`${stackCard(0)} ${stageOf("crossing")}`);
+			let stage = find(`${stackCard(0)} ${stageOf("crossing")}`);
+			await waitUntil(() => !resting(stage));
+			assert.true(await framesAskedBy(TAPE) > 0, "the tape runs in view");
+			await openTile(`${stackCard(0)} `, "enter");
+			await waitFor(`${stackCard(1)}[data-test-stack-card="${demo("enter")}"] .demo-head h1`);
+			await waitUntil(() => resting(stage));
+			assert.strictEqual(find(`${stackCard(0)} ${stageOf("crossing")}`), stage, "the covered stage is the one that was running, still mounted");
+			await stagesSettled();
+			assert.strictEqual(runningInStages(), 0, "nothing in any tile’s stage plays");
+			assert.strictEqual(await framesAskedBy(TAPE), 0, "and its own loop asks for no frames");
+			assert.strictEqual(await tileWrites(), 0, "and nothing in the grid is written to, frame after frame");
+			await click(`${stackCard(1)} [data-test-close-button]`);
+			await waitFor(stackCard(1), { count: 0 });
+			await waitUntil(() => !resting(stage));
+			assert.strictEqual(find(`${stackCard(0)} ${stageOf("crossing")}`), stage, "the same stage wakes, rather than a new one starting over");
+			assert.true(await framesAskedBy(TAPE) > 0, "its tape runs again");
+		});
+	});
+	class StubHostModeService extends HostModeService {
+		get isActive() {
+			return true;
+		}
+		get hostModeOrigin() {
+			return testHostModeRealmURL.replace(/\/test\/?$/, "");
+		}
+	}
+	(0, import_qunit.module)("on a published site", function(hooks) {
+		setupApplicationTest(hooks);
+		setupLocalIndexing(hooks);
+		setupOnSave(hooks);
+		let mockMatrixUtils = setupMockMatrix(hooks, {
+			loggedInAs: "@testuser:localhost",
+			activeRealms: [testHostModeRealmURL]
+		});
+		hooks.beforeEach(async function() {
+			let owner = getOwner(this);
+			owner.unregister?.("service:host-mode-service");
+			owner.register("service:host-mode-service", StubHostModeService);
+			mockMatrixUtils.createAndJoinRoom({
+				sender: "@testuser:localhost",
+				name: "room-test"
+			});
+			setupUserSubscription();
+			setupAuthEndpoints();
+			await setupAcceptanceTestRealm({
+				realmURL: testHostModeRealmURL,
+				mockMatrixUtils,
+				permissions: { "*": ["read"] },
+				contents: choreoGalleryRealmOf(DEMOS)
+			});
+			mockMatrixUtils.setActiveRealms([testHostModeRealmURL]);
+		});
+		const stackItem = (slug) => `[data-test-host-mode-stack-item="${testHostModeRealmURL}demos/${slug}"]`;
+		(0, import_qunit.test)("the grid’s stages rest under the stack, and carry on when it closes", async function(assert) {
+			await visit("/test");
+			await waitFor(stageOf("crossing"));
+			let stage = find(stageOf("crossing"));
+			await waitUntil(() => !resting(stage));
+			assert.true(await framesAskedBy(TAPE) > 0, "the tape runs in view");
+			await openTile("", "enter");
+			await waitFor(`${stackItem("enter")} .demo-head h1`);
+			assert.dom(".current-card").hasAttribute("inert", "", "the gallery under the stack is inert");
+			await waitUntil(() => resting(stage));
+			await stagesSettled();
+			assert.strictEqual(runningInStages(), 0, "nothing in any tile’s stage plays");
+			assert.strictEqual(await framesAskedBy(TAPE), 0, "and its own loop asks for no frames");
+			assert.strictEqual(await tileWrites(), 0, "and nothing in the grid is written to, frame after frame");
+			await click("[data-test-host-stack-item-close-button]");
+			await waitFor(stackItem("enter"), { count: 0 });
+			assert.dom(".current-card").doesNotHaveAttribute("inert", "the gallery is live again");
+			await waitUntil(() => !resting(stage));
+			assert.strictEqual(find(stageOf("crossing")), stage, "the same stage carries on");
+			assert.true(await framesAskedBy(TAPE) > 0, "its tape runs again");
+		});
+	});
+});
+//#endregion

package/bundled-test-harness/assets/{choreo-gallery-crossing-stage-test-B7jRQTAh.js → choreo-gallery-crossing-stage-test-CmGH0E5q.js}

@@ -3,7 +3,7 @@ import { T as settled, a as find } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
 import { i as orphanCount, s as strandedTransforms } from "./test-support-BLXHZ-sH.js";
-import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames, t as $ } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames, t as $ } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-crossing-stage-test.gts
 /**
 * Crossing: three looping slides, a cut at any phase, and the matching tile

package/bundled-test-harness/assets/{choreo-gallery-demos-alive-test-BLqE-zk1.js → choreo-gallery-demos-alive-test-DZ1sPqe8.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-demos-alive-test.gts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 function rest() {
@@ -12,6 +12,10 @@ function rest() {
 * too. In a gallery whose cards are whole demos that means the demos mount
 * already finished: rows that should wait for the scroll arrive in place, and
 * a looping keyframe animation is seeded at its last frame instead of running.
+*
+* The whileInView rows are what catch that: they animate from mount. A looping
+* stage starts its loop when its stage first comes on, after mount, so the
+* keyframes test asks only that the loop runs where it can be seen.
 */
 (0, import_qunit.module)("Integration | Choreo gallery | gallery demos stay alive", function(hooks) {
 	let gallery = setupChoreoGalleryTest(hooks);
@@ -23,11 +27,13 @@ function rest() {
 		const waiting = rows.filter((row) => Number(getComputedStyle(row).opacity) < .5);
 		assert.ok(waiting.length > 0, `rows below the fold are still waiting: ${rows.map((r) => getComputedStyle(r).opacity).join(",")}`);
 	});
-	(0, import_qunit.test)("a looping keyframe animation is running", async function(assert) {
+	(0, import_qunit.test)("a looping keyframe animation runs once its tile is on stage", async function(assert) {
 		await gallery.renderGallery();
 		await rest();
 		const morph = document.querySelector(".morph");
 		assert.ok(morph, "the keyframes demo rendered");
+		morph.scrollIntoView({ block: "center" });
+		await rest();
 		const running = morph.getAnimations().concat([...morph.parentElement?.getAnimations() ?? []]);
 		const animating = running.length > 0 || Number(getComputedStyle(morph).opacity) < 1;
 		assert.ok(animating, `something is animating on it: ${running.length}`);

package/bundled-test-harness/assets/{choreo-gallery-drift-test-DOXLQNB9.js → choreo-gallery-drift-test-q7KosXIw.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-drift-test.ts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 var applied;

package/bundled-test-harness/assets/{choreo-gallery-escort-test-lfBfmp-4.js → choreo-gallery-escort-test-CH_qyw6w.js}

@@ -1,7 +1,7 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { a as find, d as click } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-escort-test.gts
 /**
 * Escort — the acceptance page for the opened step vocabulary

package/bundled-test-harness/assets/{choreo-gallery-films-test-M761cc8Q.js → choreo-gallery-films-test-CYmek5qU.js}

@@ -6,7 +6,7 @@ import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestR
 import { r as getService } from "./dist-BE9MasZr.js";
 import { o as setupChoreo } from "./test-support-BLXHZ-sH.js";
 import { vt as setupBaseRealm } from "./base-realm-DMaIwpS6.js";
-import { t as choreoGalleryContents } from "./choreo-gallery-B0nnktwP.js";
+import { t as choreoGalleryContents } from "./choreo-gallery-D8__QZCe.js";
 import { t as renderCard } from "./render-component-PtY1yFne.js";
 //#region tests/integration/choreo-gallery-films-test.gts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());

package/bundled-test-harness/assets/{choreo-gallery-filter-test-BrUWMDaJ.js → choreo-gallery-filter-test-Curg5Fg7.js}

@@ -1,7 +1,7 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { d as click } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest, i as galleryInstance, n as GALLERY_DEMOS } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, i as galleryInstance, n as GALLERY_DEMOS } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-filter-test.gts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 /** the catalog: every linked demo, with the group it files under */

package/bundled-test-harness/assets/{choreo-gallery-fold-test-CTtdGSAI.js → choreo-gallery-fold-test-BDTkaH6H.js}

@@ -2,7 +2,7 @@ import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { T as settled } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-fold-test.gts
 /**
 * The Fold demo's argument, asserted.

package/bundled-test-harness/assets/{choreo-gallery-guides-test-PHmvqxfk.js → choreo-gallery-guides-test-B1vY7Fkx.js}

@@ -14,8 +14,8 @@ import { M as waitUntil, d as click, h as render, o as waitFor } from "./dist-BG
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import "./mock-matrix-CJaQa5Mm.js";
 import { n as live, r as liveAll } from "./test-support-BLXHZ-sH.js";
-import { n as choreoGalleryGuides } from "./choreo-gallery-B0nnktwP.js";
-import { a as setupChoreoGalleryTest, i as galleryInstance, n as GALLERY_DEMOS } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { n as choreoGalleryGuides } from "./choreo-gallery-D8__QZCe.js";
+import { a as setupChoreoGalleryTest, i as galleryInstance, n as GALLERY_DEMOS } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-guides-test.gts
 /**
 * The guides, their links and the lab: a guide renders from the realm with

package/bundled-test-harness/assets/{choreo-gallery-hang-test-DP5lQG0y.js → choreo-gallery-hang-test-BJJghTnK.js}

@@ -2,7 +2,7 @@ import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { T as settled } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest, l as trigger, o as setupStageViewport, r as frames, s as sleep, t as $ } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, l as trigger, o as setupStageViewport, r as frames, s as sleep, t as $ } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-hang-test.gts
 /**
 * Hang's argument, asserted: a throw is READ, and the reading is what puts

package/bundled-test-harness/assets/{choreo-gallery-highlight-test-CLhvRo6X.js → choreo-gallery-highlight-test-DGT0jmDf.js}

@@ -1,7 +1,7 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { t as choreoGalleryContents } from "./choreo-gallery-B0nnktwP.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { t as choreoGalleryContents } from "./choreo-gallery-D8__QZCe.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-highlight-test.ts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 var highlightSample;

package/bundled-test-harness/assets/{choreo-gallery-inline-edit-test-jOddqOxH.js → choreo-gallery-inline-edit-test-DwF8ZeCB.js}

@@ -2,7 +2,7 @@ import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { a as find, d as click, s as fillIn } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-inline-edit-test.gts
 /**
 * The Inline Edit demo: a record read, then written.

package/bundled-test-harness/assets/{choreo-gallery-interruption-test-hdQSH8Mi.js → choreo-gallery-interruption-test-DvfkLdWd.js}

@@ -5,7 +5,7 @@ import { i as setMotionSpeed } from "./speed-bIo0tyrM.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
 import { i as orphanCount, s as strandedTransforms } from "./test-support-BLXHZ-sH.js";
-import { a as setupChoreoGalleryTest, o as setupStageViewport, s as sleep } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, o as setupStageViewport, s as sleep } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-interruption-test.gts
 /**
 * Rapid interruption, across every stage in the gallery.

package/bundled-test-harness/assets/{choreo-gallery-lone-stack-test-AHGiG8yJ.js → choreo-gallery-lone-stack-test-CDwE2xKJ.js}

@@ -13,7 +13,7 @@ import { t as LayoutGroup } from "./layout-group-Btk-S82w.js";
 import { t as MotionModifier } from "./motion-CU0yC2Ky.js";
 import { t as Presence } from "./presence-BYtEBpVa.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-lone-stack-test.gts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 var keyOf = (item) => item.id;

package/bundled-test-harness/assets/{choreo-gallery-navigation-test-BlGmMyFM.js → choreo-gallery-navigation-test-DG6IdX6k.js}

@@ -5,7 +5,7 @@ import { t as HostModeService } from "./host-mode-service-CtK92ze8.js";
 import { T as settled, d as click, k as visit, o as waitFor, y as currentURL } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { F as setupLocalIndexing, I as setupOnSave, ct as setupApplicationTest, j as setupAcceptanceTestRealm, pt as setupAuthEndpoints, st as visitOperatorMode, t as setupMockMatrix, z as setupUserSubscription } from "./mock-matrix-CJaQa5Mm.js";
-import { r as choreoGalleryRealmOf } from "./choreo-gallery-B0nnktwP.js";
+import { r as choreoGalleryRealmOf } from "./choreo-gallery-D8__QZCe.js";
 //#region tests/acceptance/choreo-gallery-navigation-test.gts
 /**
 * Moving around the Choreo gallery is the host's: each tile is the demo

package/bundled-test-harness/assets/{choreo-gallery-playhead-transport-test-8aNOk09i.js → choreo-gallery-playhead-transport-test-CITO-DAn.js}

@@ -1,7 +1,7 @@
 import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { M as waitUntil, T as settled } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest, r as frames } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, r as frames } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-playhead-transport-test.gts
 /**
 * The Playhead demo on `c.run` — the score is a <c.Sequence>, the presses

package/bundled-test-harness/assets/{choreo-gallery-poplayout-subtree-test-BCJLJdyC.js → choreo-gallery-poplayout-subtree-test-Cs4S9Ky9.js}

@@ -16,7 +16,7 @@ import { t as MotionModifier } from "./motion-CU0yC2Ky.js";
 import { t as Presence } from "./presence-BYtEBpVa.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest, c as stageWellStyle, o as setupStageViewport, s as sleep } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, c as stageWellStyle, o as setupStageViewport, s as sleep } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-poplayout-subtree-test.gts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 var keyOf = (demo) => demo.slug;

package/bundled-test-harness/assets/{choreo-gallery-presence-modes-test-CbhdndwS.js → choreo-gallery-presence-modes-test-p8mppXAD.js}

@@ -2,7 +2,7 @@ import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { a as find, d as click } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { n as bounds, t as animationsSettled } from "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-presence-modes-test.gts
 /**
 * What `sync` actually does to the layout — asserted, because it reads as a

package/bundled-test-harness/assets/{choreo-gallery-presentation-test-DDUagg6a.js → choreo-gallery-presentation-test-CT0lZepE.js}

@@ -2,7 +2,7 @@ import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { M as waitUntil, c as triggerKeyEvent, d as click, f as focus } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest, r as frames } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, r as frames } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-presentation-test.gts
 /**
 * Presentation — gates as presenter mode (packages/choreo-gallery/realm/docs/choreo-constructs.md §8.1).
@@ -15,6 +15,8 @@ function run() {
 	return host()?.presentation?.c?.run ?? null;
 }
 var opacityOf = (sel) => parseFloat(getComputedStyle(document.querySelector(sel)).opacity);
+/** the deck's key cue: the Space / ‹ › hint shows only while it is lit */
+var keyCueShows = () => getComputedStyle(document.querySelector(".pres-keys")).visibility === "visible";
 (0, import_qunit.module)("Integration | Choreo gallery | presentation", function(hooks) {
 	let gallery = setupChoreoGalleryTest(hooks);
 	let Presentation;
@@ -118,5 +120,38 @@ var opacityOf = (sel) => parseFloat(getComputedStyle(document.querySelector(sel)
 		assert.strictEqual(title?.getAttribute("data-arrive"), "back");
 		assert.ok(opacityOf(".pres-title") > .9, "back shows the title slide already built");
 	});
+	(0, import_qunit.test)("the bar takes Tab, and a key on a bar control is that control's own", async function(assert) {
+		await gallery.renderStage(Presentation);
+		await waitUntil(() => {
+			const r = run();
+			return Boolean(r?.parked && r.segment === 1);
+		}, { timeout: 4e3 });
+		const deck = document.querySelector("[data-test-pres]");
+		const controls = [
+			"[data-test-pres-seg=\"0\"]",
+			"[data-test-pres-xfade]",
+			"[data-test-pres-restart]",
+			"[data-test-pres-back]",
+			"[data-test-pres-fwd]"
+		].map((selector) => document.querySelector(selector));
+		for (const control of controls) assert.strictEqual(control.tabIndex, 0, "a bar control is a tab stop");
+		const restart = document.querySelector("[data-test-pres-restart]");
+		await focus(restart);
+		assert.false(keyCueShows(), "focus on a bar control leaves the cue dark");
+		await triggerKeyEvent(restart, "keydown", " ");
+		await triggerKeyEvent(restart, "keydown", "ArrowRight");
+		await frames(1);
+		assert.true(run().parked, "the deck did not take the keys");
+		assert.strictEqual(run().segment, 1, "no build moved");
+		const fwd = document.querySelector("[data-test-pres-fwd]");
+		await click(fwd);
+		assert.strictEqual(document.activeElement, fwd, "a keyboard press leaves focus on the control");
+		assert.false(keyCueShows(), "a keyboard press leaves the cue dark");
+		await animationsSettled();
+		await click(fwd, { detail: 1 });
+		assert.strictEqual(document.activeElement, deck, "a pointer press hands focus to the deck");
+		assert.true(keyCueShows(), "the deck that takes the keys lights the cue");
+		await animationsSettled();
+	});
 });
 //#endregion

package/bundled-test-harness/assets/{choreo-gallery-sheet-standalone-test-BNyhCtW2.js → choreo-gallery-sheet-standalone-test-D-MLCQ6u.js}

@@ -8,7 +8,7 @@ import { d as click } from "./dist-BGqriEf8.js";
 import "./src-DKlevVIu.js";
 import { t as LayoutGroup } from "./layout-group-Btk-S82w.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { a as setupChoreoGalleryTest, r as frames } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, r as frames } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-sheet-standalone-test.gts
 /**
 * Every distinct reading over a wall-clock window.

package/bundled-test-harness/assets/{choreo-gallery-sheet-test-NEe_oYnA.js → choreo-gallery-sheet-test-unHvAt2e.js}

@@ -2,7 +2,7 @@ import { s as __toESM } from "./chunk-Rp0pCe6z.js";
 import { d as click } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { t as animationsSettled } from "./test-support-foMaafLc.js";
-import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-sheet-test.gts
 var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
 /** the sheet's own y, read off the element rather than off the props */ function offset(el) {

package/bundled-test-harness/assets/{choreo-gallery-site-test-hT5mISBG.js → choreo-gallery-site-test-BRHuPInI.js}

@@ -12,7 +12,7 @@ import { d as click, h as render, o as waitFor } from "./dist-BGqriEf8.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { nt as provide } from "./mock-matrix-CJaQa5Mm.js";
 import { n as live, r as liveAll } from "./test-support-BLXHZ-sH.js";
-import { a as setupChoreoGalleryTest, n as GALLERY_DEMOS } from "./choreo-gallery-stage-Bmz9m8sP.js";
+import { a as setupChoreoGalleryTest, n as GALLERY_DEMOS } from "./choreo-gallery-stage-DVGS6XI-.js";
 //#region tests/integration/choreo-gallery-site-test.gts
 /**
 * The gallery site, whole: the gallery card as the realm serves it — every

package/bundled-test-harness/assets/{choreo-gallery-stage-Bmz9m8sP.js → choreo-gallery-stage-DVGS6XI-.js}

@@ -12,7 +12,7 @@ import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestR
 import { r as getService } from "./dist-BE9MasZr.js";
 import { o as setupChoreo } from "./test-support-BLXHZ-sH.js";
 import { vt as setupBaseRealm } from "./base-realm-DMaIwpS6.js";
-import { t as choreoGalleryContents } from "./choreo-gallery-B0nnktwP.js";
+import { t as choreoGalleryContents } from "./choreo-gallery-D8__QZCe.js";
 import { t as renderCard } from "./render-component-PtY1yFne.js";
 //#region tests/helpers/choreo-gallery-stage.gts
 /** a card instance document in the gallery realm, as much as the tests read */

package/bundled-test-harness/assets/choreo-gallery-stage-keyboard-test-BYpAwZPD.js

@@ -0,0 +1,102 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { M as waitUntil, c as triggerKeyEvent, d as click, f as focus } from "./dist-BGqriEf8.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { t as animationsSettled } from "./test-support-foMaafLc.js";
+import { a as setupChoreoGalleryTest } from "./choreo-gallery-stage-DVGS6XI-.js";
+//#region tests/integration/choreo-gallery-stage-keyboard-test.gts
+/**
+* The stages' keyboard paths: every focusable part of a stage shows the
+* site's focus ring, and what a pointer does on a stage's open surface a
+* key can do too.
+*/ var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+/** the focus ring the browser draws on `el` once it has keyboard focus */
+async function ringOn(el) {
+	await focus(el);
+	let style = getComputedStyle(el);
+	return {
+		focusVisible: el.matches(":focus-visible"),
+		outline: style.outlineStyle,
+		color: style.outlineColor
+	};
+}
+/** the theme's focus color, `--ring`, as it resolves where `el` sits */
+function themeRing(el) {
+	let probe = document.createElement("i");
+	probe.style.color = "var(--ring)";
+	el.parentElement.append(probe);
+	let color = getComputedStyle(probe).color;
+	probe.remove();
+	return color;
+}
+/** the keydown that reaches the document, if a stage lets it through */
+async function keyAtDocument(el, key) {
+	let seen;
+	let listen = (event) => seen = event;
+	document.addEventListener("keydown", listen);
+	try {
+		await triggerKeyEvent(el, "keydown", key);
+	} finally {
+		document.removeEventListener("keydown", listen);
+	}
+	return seen;
+}
+(0, import_qunit.module)("Integration | Choreo gallery | stage keyboard", function(hooks) {
+	let gallery = setupChoreoGalleryTest(hooks);
+	(0, import_qunit.test)("a camera print shows the focus ring", async function(assert) {
+		await gallery.renderStage(await gallery.stage("camera", "Camera"));
+		let print = document.querySelector("[data-test-cam-print]");
+		let ring = await ringOn(print);
+		assert.true(ring.focusVisible, "the print has keyboard focus");
+		assert.notStrictEqual(ring.outline, "none", "the print draws a ring");
+		assert.strictEqual(ring.color, themeRing(print), "the ring is drawn in the theme's --ring");
+	});
+	(0, import_qunit.test)("Escape backs out of a camera dive and returns focus to the print", async function(assert) {
+		await gallery.renderStage(await gallery.stage("camera", "Camera"));
+		let print = document.querySelector("[data-test-cam-print]");
+		assert.strictEqual(print.getAttribute("aria-pressed"), "false");
+		await focus(print);
+		await click(print);
+		await waitUntil(() => document.querySelector("[data-test-cam-love]"));
+		assert.strictEqual(print.getAttribute("aria-pressed"), "true", "the open print reads as pressed");
+		let love = document.querySelector("[data-test-cam-love]");
+		await focus(love);
+		let reached = await keyAtDocument(love, "Escape");
+		await animationsSettled();
+		assert.strictEqual(reached, void 0, "the stage kept the key");
+		assert.dom("[data-test-cam-love]").doesNotExist("the dive closed");
+		assert.strictEqual(print.getAttribute("aria-pressed"), "false");
+		assert.strictEqual(document.activeElement, print, "focus is back on the print that was open");
+	});
+	(0, import_qunit.test)("a pointer dive leaves focus on the print, so Escape backs out of it", async function(assert) {
+		await gallery.renderStage(await gallery.stage("camera", "Camera"));
+		let print = document.querySelector("[data-test-cam-print]");
+		print.dispatchEvent(new MouseEvent("click", {
+			bubbles: true,
+			detail: 1
+		}));
+		await waitUntil(() => document.querySelector("[data-test-cam-love]"));
+		assert.strictEqual(document.activeElement, print, "the open print has focus");
+		assert.false(print.matches(":focus-visible"), "a pointer dive draws no focus ring");
+		let reached = await keyAtDocument(print, "Escape");
+		await animationsSettled();
+		assert.strictEqual(reached, void 0, "the stage kept the key");
+		assert.dom("[data-test-cam-love]").doesNotExist("the dive closed");
+	});
+	(0, import_qunit.test)("Escape with no dive open is left for the host", async function(assert) {
+		await gallery.renderStage(await gallery.stage("camera", "Camera"));
+		let print = document.querySelector("[data-test-cam-print]");
+		await focus(print);
+		let reached = await keyAtDocument(print, "Escape");
+		assert.ok(reached, "the key reaches the host");
+		assert.false(reached.defaultPrevented, "the stage left it alone");
+	});
+	(0, import_qunit.test)("a wires mark and comment show the focus ring", async function(assert) {
+		await gallery.renderStage(await gallery.stage("wires", "Wires"));
+		for (let selector of ["[data-test-wires-mark]", "[data-test-wires-note]"]) {
+			let ring = await ringOn(document.querySelector(selector));
+			assert.true(ring.focusVisible, `${selector} has keyboard focus`);
+			assert.notStrictEqual(ring.outline, "none", `${selector} draws a ring`);
+		}
+	});
+});
+//#endregion