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

package/bundled-test-harness/assets/choreo-gallery-widget-room-test-o9T2EFKq.js

@@ -0,0 +1,88 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { M as waitUntil, T as settled, d as click, h as render } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { t as choreoGalleryContents } from "./choreo-gallery-DZm1KZ20.js";
+import { a as setupChoreoGalleryTest, n as GALLERY_DEMOS, o as setupStageViewport, r as frames } from "./choreo-gallery-stage-Dj6tFzon.js";
+//#region tests/integration/choreo-gallery-widget-room-test.gts
+/**
+* The widget room: every demo the gallery links hangs on a wall, and a tile
+* the visitor focuses mounts its live stage. The room's code finds demos and
+* their controls through hooks of its own and the demos' own markup, never
+* through a test selector.
+*/ var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | Choreo gallery | widget room", function(hooks) {
+	let gallery = setupChoreoGalleryTest(hooks);
+	setupStageViewport(hooks, {
+		width: 1200,
+		height: 800
+	});
+	async function renderRoom() {
+		let { WidgetRoom, roomDemos } = await gallery.import("shell/widget-room");
+		let demos = roomDemos(await gallery.demos());
+		await render(setComponentTemplate(templateFactory({
+			"id": "RsTNtoST",
+			"block": "[[[8,[32,0],null,[[\"@demos\",\"@homeHref\"],[[32,1],\"https://example.test/\"]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/choreo-gallery-widget-room-test.gts",
+			"scope": () => [WidgetRoom, demos],
+			"isStrictMode": true
+		}), templateOnly()));
+		await waitUntil(() => document.querySelector(".wr-world")?.style.transform, { timeout: 1e4 });
+	}
+	(0, import_qunit.test)("hangs every demo the gallery links, each in a bay", async function(assert) {
+		let { galleryZones } = await gallery.import("lib/widget-gallery-layout");
+		let zoned = new Set(galleryZones.flat());
+		await renderRoom();
+		let hung = [...document.querySelectorAll("[data-widget-id]")].map((tile) => tile.dataset.widgetId).sort();
+		assert.deepEqual(hung, GALLERY_DEMOS.filter((slug) => zoned.has(slug)).sort(), "one tile per linked demo a bay names");
+		assert.deepEqual(GALLERY_DEMOS.filter((slug) => !zoned.has(slug)), [], "and every linked demo has a bay");
+	});
+	(0, import_qunit.test)("focusing a tile mounts its live stage", async function(assert) {
+		await renderRoom();
+		let tile = "[data-widget-id=\"keyframes\"]";
+		assert.dom(`${tile} .wr-live-canvas`).hasNoText("a distant tile shows its preview, not its stage");
+		await click(`${tile} .wr-live-hit`);
+		await waitUntil(() => document.querySelector(`${tile} .wr-live-canvas`).childElementCount > 0, { timeout: 5e3 });
+		await settled();
+		assert.dom(`${tile} .wr-live-canvas .morph`).exists("the Keyframes stage is live in the tile");
+		assert.dom(".wr-shell").hasClass("has-selection", "the room reports the selection");
+	});
+	(0, import_qunit.test)("a camera move stopped mid-flight holds where it stands", async function(assert) {
+		let { moveRoomCamera } = await gallery.import("lib/widget-camera");
+		let from = {
+			dolly: 1,
+			pitch: 0,
+			x: 0,
+			y: 0,
+			yaw: 0
+		};
+		let to = {
+			dolly: 2,
+			pitch: 10,
+			x: 0,
+			y: 0,
+			yaw: 90
+		};
+		let poses = [];
+		let run = moveRoomCamera(from, to, (pose) => poses.push(pose), 600);
+		await frames(6);
+		assert.ok(poses.length > 0, "the move painted while it ran");
+		let before = poses.length;
+		let last = poses[before - 1].yaw;
+		run.cancel();
+		await frames(6);
+		assert.strictEqual(poses.length, before, "nothing is painted after a stop");
+		assert.ok(last > 0, `the camera held mid-move (yaw ${last.toFixed(1)})`);
+		await run.finished;
+		assert.ok(true, "and the stopped move settles");
+	});
+	(0, import_qunit.test)("no gallery module finds anything by a test selector", function(assert) {
+		let offenders = Object.entries(choreoGalleryContents()).filter(([path]) => /\.(gts|ts)$/.test(path)).filter(([, source]) => /\[data-test-/.test(source)).map(([path]) => path);
+		assert.deepEqual(offenders, [], "test selectors are for tests");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/choreo-gallery-wires-test-73JLkxn6.js

@@ -0,0 +1,148 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory, m as htmlSafe } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import "./template-C81fYDrq.js";
+import { M as waitUntil, a as find, d as click, h as render, l as triggerEvent } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { t as animationsSettled } from "./test-support-BOFeeYuE.js";
+import { a as setupChoreoGalleryTest, c as stageWellStyle, r as frames } from "./choreo-gallery-stage-Dj6tFzon.js";
+//#region tests/integration/choreo-gallery-wires-test.gts
+/**
+* Wires — c.Tether (packages/choreo-gallery/realm/docs/choreo-constructs.md §6.1, §8.1).
+* A morning note in three drafts: marks in the prose, comments in the
+* margin, cubics derived every frame. Versions reflow the copy; the
+* selected pair shows its thread (first comment on by default).
+*/
+/** a scaled, shifted ancestor, so the demo is carried by a transform */
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var transformed = htmlSafe("transform: scale(0.82) translate(40px, 24px); transform-origin: 0 0");
+var well = stageWellStyle();
+(0, import_qunit.module)("Integration | Choreo gallery | wires", function(hooks) {
+	let gallery = setupChoreoGalleryTest(hooks);
+	let Wires;
+	hooks.beforeEach(async function() {
+		Wires = await gallery.stage("wires", "Wires");
+	});
+	/**
+	* The resting threads are DERIVED geometry: the modifier waits a frame
+	* for layout, then draws, and redraws again while the region's own
+	* tethers are aloft. `animationsSettled()` says the run is done — it
+	* cannot know a post-render painter still owes a frame — so the count
+	* is waited for rather than sampled.
+	*/
+	const resting = () => document.querySelectorAll(".wires-rest path").length;
+	const restingCount = (n) => waitUntil(() => resting() === n, { timeout: 2e3 });
+	/**
+	* The narrow layout is a different geometry, not a smaller one.
+	*
+	* Below 460px the board stops being two columns and puts the comments UNDER
+	* the note, because a 148px floor on the margin column was leaving 110px for
+	* the prose and wrapping a three-sentence note to nine lines. A tether is
+	* derived from where its two ends actually are, so the only thing that has
+	* to hold is that it still finds them — the wire runs downward instead of
+	* sideways and is otherwise the same construct.
+	*/
+	(0, import_qunit.test)("the threads still draw when the comments stack under the note", async function(assert) {
+		await gallery.renderStage(Wires, {
+			width: 360,
+			height: 620
+		});
+		await animationsSettled();
+		await restingCount(2);
+		assert.strictEqual(resting(), 2, "two resting threads at phone width");
+		const copy = find(".wires-copy");
+		const margin = find(".wires-margin");
+		assert.true(margin.offsetTop >= copy.offsetTop + copy.offsetHeight - 2, "the comments are laid out below the note, not beside it");
+		const board = find(".wires-board");
+		assert.strictEqual(getComputedStyle(board).gridTemplateColumns.split(" ").length, 1, "the board is one column");
+		assert.true(copy.offsetWidth > 200, `the prose gets the full width back ${JSON.stringify({
+			board: board.offsetWidth,
+			cols: getComputedStyle(board).gridTemplateColumns,
+			copy: copy.offsetWidth
+		})}`);
+		const paths = [...document.querySelectorAll(".wires-rest path")];
+		assert.true(paths.every((p) => p.getTotalLength() > 0), "every thread has real length — the ends were found");
+	});
+	(0, import_qunit.test)("a version pass keeps a live tether inside a moving comment", async function(assert) {
+		await gallery.renderStage(Wires);
+		await animationsSettled();
+		await restingCount(2);
+		assert.strictEqual(resting(), 2, "V1 draws two resting threads");
+		await click("[data-test-wires-v=\"V2\"]");
+		await frames(1);
+		const path = find("[data-choreo-tether]");
+		assert.ok(path, "the run draws tethers for the window");
+		const nums = [...(path.getAttribute("d") ?? "").matchAll(/-?\d+\.?\d*/g)].map(Number);
+		const endX = nums[nums.length - 2];
+		const note = find("[data-test-wires-note=\"gauge\"]");
+		const layer = find("[data-choreo-tethers]");
+		const tBox = note.getBoundingClientRect();
+		const inverse = layer.getScreenCTM()?.inverse();
+		const localX = inverse ? new DOMPoint(tBox.left, tBox.top).matrixTransform(inverse).x : tBox.left - layer.getBoundingClientRect().left;
+		assert.true(Math.abs(endX - localX) < 10, `the wire ends in the moving comment (${endX} vs ${localX})`);
+		await animationsSettled();
+		assert.dom("[data-test-wires-note=\"hed\"]").exists();
+		await restingCount(3);
+		assert.strictEqual(resting(), 3, "V2 draws the inserted thread");
+	});
+	(0, import_qunit.test)("resting ink holds its marks inside a transformed ancestor", async function(assert) {
+		const { ChoreoRoot } = await gallery.import("shell/choreo-root");
+		const Stage = Wires;
+		const Carried = setComponentTemplate(templateFactory({
+			"id": "TZVF/n0y",
+			"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[10,0],[15,5,[32,1]],[12],[1,\"\\n    \"],[10,0],[14,0,\"choreo-stage-well\"],[15,5,[32,2]],[12],[1,\"\\n      \"],[8,[32,3],null,null,null],[1,\"\\n    \"],[13],[1,\"\\n  \"],[13],[1,\"\\n\"]],[]]]]]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/choreo-gallery-wires-test.gts",
+			"scope": () => [
+				ChoreoRoot,
+				transformed,
+				well,
+				Stage
+			],
+			"isStrictMode": true
+		}), templateOnly());
+		await render(setComponentTemplate(templateFactory({
+			"id": "DMEHpfGh",
+			"block": "[[[8,[32,0],null,null,null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/choreo-gallery-wires-test.gts",
+			"scope": () => [Carried],
+			"isStrictMode": true
+		}), templateOnly()));
+		await animationsSettled();
+		await restingCount(2);
+		const t = find(".wires-thread[data-thread=\"gauge\"]");
+		const mark = find("[data-node=\"m-gauge\"]");
+		const d = t.getAttribute("d") ?? "";
+		const m = /M (-?[\d.]+) (-?[\d.]+)/.exec(d);
+		const inverse = t.ownerSVGElement.getScreenCTM().inverse();
+		const r = mark.getBoundingClientRect();
+		const p = new DOMPoint(r.right, r.top + r.height / 2).matrixTransform(inverse);
+		const err = Math.hypot(p.x - Number(m[1]), p.y - Number(m[2]));
+		assert.true(err < 2, `the thread starts ON its mark under the transform (${err.toFixed(1)}px off)`);
+	});
+	(0, import_qunit.test)("stepping back removes the inserted comment; the first pair stays selected", async function(assert) {
+		await gallery.renderStage(Wires);
+		await animationsSettled();
+		await restingCount(2);
+		const host = find("[data-test-wires]");
+		assert.strictEqual(host.getAttribute("data-hot"), "gauge", "the first comment is selected on load");
+		const first = find(".wires-thread[data-thread=\"gauge\"]");
+		assert.true(parseFloat(getComputedStyle(first).opacity) > .5, "its thread is drawn at rest");
+		await click("[data-test-wires-v=\"V2\"]");
+		await animationsSettled();
+		await click("[data-test-wires-v=\"V1\"]");
+		await animationsSettled();
+		assert.dom("[data-test-wires-note=\"hed\"]").doesNotExist();
+		await restingCount(2);
+		assert.strictEqual(resting(), 2, "the inserted thread is gone");
+		await triggerEvent(find("[data-test-wires-note=\"edition\"]"), "pointerenter");
+		assert.strictEqual(host.getAttribute("data-hot"), "edition", "hover moves the selection without a rerender");
+		const thread = find(".wires-thread[data-thread=\"edition\"]");
+		const lit = () => parseFloat(getComputedStyle(thread).opacity);
+		await waitUntil(() => lit() > .5, { timeout: 1e3 });
+		assert.true(lit() > .5, "the resting cubic follows the selected pair");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/client-telemetry-test-DFM4mML2.js

@@ -0,0 +1,340 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { An as X_BOXEL_LOGGING_CORRELATION_ID_HEADER } from "./runtime-common-BTaLJEw-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { u as createServerRequestTimingMiddleware } from "./realm-C_a9su1j.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { t as suspendGlobalErrorHook } from "./uncaught-exceptions-Cm9iqRb6.js";
+//#region tests/integration/client-telemetry-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+function dispatchUncaught(error, location = {}) {
+	let message = error?.message;
+	let savedOnError = window.onerror;
+	window.onerror = null;
+	try {
+		window.dispatchEvent(new ErrorEvent("error", {
+			message: `Uncaught ${typeof message === "string" ? message : String(error)}`,
+			filename: location.filename ?? "",
+			lineno: location.lineno ?? 0,
+			colno: location.colno ?? 0,
+			error
+		}));
+	} finally {
+		window.onerror = savedOnError;
+	}
+}
+function assertNoGlobalErrorReported(assert, body, message) {
+	let reported = 0;
+	let savedOnError = window.onerror;
+	window.onerror = () => {
+		reported++;
+		return true;
+	};
+	try {
+		body();
+	} finally {
+		window.onerror = savedOnError;
+	}
+	assert.strictEqual(reported, 0, message);
+}
+function dispatchRejection(reason) {
+	let promise = Promise.reject(reason);
+	promise.catch(() => {});
+	window.dispatchEvent(new PromiseRejectionEvent("unhandledrejection", {
+		promise,
+		reason
+	}));
+}
+function errorWithStack(message, frames) {
+	let error = new Error(message);
+	error.stack = [`Error: ${message}`, ...frames].join("\n");
+	return error;
+}
+function frames(count, width = 1) {
+	return Array.from({ length: count }, (_, i) => `    at frame${i} (https://realm.example/my-realm/${"d".repeat(width)}.gts:${i + 1}:1)`);
+}
+(0, import_qunit.module)("Integration | Service | client-telemetry", function(hooks) {
+	setupRenderingTest(hooks);
+	setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		autostart: true
+	});
+	let { capturedExceptions } = suspendGlobalErrorHook(hooks);
+	function telemetry() {
+		return getService("client-telemetry");
+	}
+	function clientErrors(svc) {
+		return svc.drainBufferForTest().filter((e) => e.event_type === "client-error");
+	}
+	hooks.afterEach(function() {
+		telemetry().teardown();
+		capturedExceptions.length = 0;
+	});
+	(0, import_qunit.test)("is disabled under tests until explicitly opted in", function(assert) {
+		let svc = telemetry();
+		assert.false(svc.isEnabled, "dormant under isTesting() by default");
+		svc.enableForTest();
+		assert.true(svc.isEnabled, "armed after enableForTest()");
+	});
+	(0, import_qunit.test)("records a server-request event with a normalized endpoint", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		let req = new Request("https://realm.example/my-realm/_search", { method: "POST" });
+		let res = new Response("{}", {
+			status: 200,
+			headers: {
+				"content-length": "2",
+				"x-boxel-realm-url": "https://realm.example/my-realm/"
+			}
+		});
+		svc.recordServerRequestTiming(req, res, 42.7, true);
+		let events = svc.drainBufferForTest();
+		assert.strictEqual(events.length, 1, "one event buffered");
+		let e = events[0];
+		assert.strictEqual(e.event_type, "server-request");
+		assert.strictEqual(e.endpoint, "_search", "underscore endpoint collapses");
+		assert.strictEqual(e.method, "POST");
+		assert.strictEqual(e.status, 200);
+		assert.strictEqual(e.duration_ms, 43, "duration is rounded");
+		assert.strictEqual(e.resp_bytes, 2);
+		assert.true(e.retried, "retried flag carried through");
+		assert.strictEqual(e.realm, "https://realm.example/my-realm/");
+		assert.strictEqual(typeof e.ts, "number", "timestamp stamped");
+		assert.notOk("search_cache" in e, "a response the search cache did not serve carries no outcome for it");
+	});
+	(0, import_qunit.test)("carries the live-search cache outcome when the response names one", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		svc.recordServerRequestTiming(new Request("https://realm.example/_federated-search", { method: "POST" }), new Response("{}", {
+			status: 200,
+			headers: {
+				"content-length": "2",
+				"x-boxel-live-search-cache": "hit"
+			}
+		}), 12, false);
+		let e = svc.drainBufferForTest()[0];
+		assert.strictEqual(e.search_cache, "hit", "how the cache served this request is attributable to the request itself");
+	});
+	(0, import_qunit.test)("normalizes a card GET to a low-cardinality label", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		svc.recordServerRequestTiming(new Request("https://realm.example/my-realm/Person/abc123", { method: "GET" }), new Response(null, { status: 200 }), 10, false);
+		let e = svc.drainBufferForTest()[0];
+		assert.strictEqual(e.endpoint, "GET card", "an instance id collapses to \"GET card\" (no per-id cardinality)");
+	});
+	(0, import_qunit.test)("records a deserialize event with doc size and card type", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		let doc = {
+			data: { id: "x" },
+			included: [{}, {}]
+		};
+		Object.defineProperty(doc, Symbol.for("boxel-doc-response-bytes"), {
+			value: 4096,
+			enumerable: false
+		});
+		svc.recordDeserialize({
+			durationMs: 12.2,
+			doc,
+			resource: { meta: {
+				adoptsFrom: {
+					module: "https://realm.example/my-realm/person",
+					name: "Person"
+				},
+				realmURL: "https://realm.example/my-realm/"
+			} }
+		});
+		let e = svc.drainBufferForTest()[0];
+		assert.strictEqual(e.event_type, "deserialize");
+		assert.strictEqual(e.duration_ms, 12);
+		assert.strictEqual(e.included_count, 2);
+		assert.strictEqual(e.card_type, "https://realm.example/my-realm/person/Person", "the type is addressed by module and export, not a bare class name");
+		assert.strictEqual(e.realm, "https://realm.example/my-realm/");
+		assert.strictEqual(e.doc_bytes, 4096, "doc size is read from the stamped response byte size");
+	});
+	(0, import_qunit.test)("a recorded event carries the wedge breadcrumb shape", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		svc.recordEvent({
+			event_type: "wedge",
+			duration_ms: 3e3,
+			worst_gap_ms: 3e3,
+			blocked_ms: 2900,
+			longtask_count: 4,
+			top_frame_function: "compute",
+			top_frame_url: "https://realm.example/my-realm/person",
+			top_frame_char: 120,
+			top_frame_blocked_ms: 2800,
+			top_frames: "compute @ https://realm.example/my-realm/person:120",
+			loaf_scripts: [{
+				source_url: "https://realm.example/my-realm/person",
+				function_name: "compute",
+				char_position: 120,
+				invoker: "classAttribute",
+				blocking_duration_ms: 2800
+			}]
+		});
+		let e = svc.drainBufferForTest()[0];
+		assert.strictEqual(e.event_type, "wedge");
+		assert.strictEqual(e.blocked_ms, 2900);
+		assert.strictEqual(e.top_frame_function, "compute", "the wedging frame is surfaced as a scalar field");
+		assert.strictEqual(e.loaf_scripts[0].function_name, "compute");
+	});
+	(0, import_qunit.test)("records a client-error event for an uncaught window error", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		let thrown = /* @__PURE__ */ new Error("boom");
+		assertNoGlobalErrorReported(assert, () => dispatchUncaught(thrown, {
+			filename: "https://realm.example/my-realm/person.gts",
+			lineno: 42,
+			colno: 7
+		}), "a synthetic throw stays invisible to the harness's global error reporting");
+		let events = clientErrors(svc);
+		assert.strictEqual(events.length, 1, "one client-error event buffered");
+		let e = events[0];
+		assert.strictEqual(e.kind, "error", "the uncaught-throw channel");
+		assert.strictEqual(e.message, "Error: boom", "the message names the error class, which message alone never carries");
+		assert.strictEqual(e.source_url, "https://realm.example/my-realm/person.gts");
+		assert.strictEqual(e.line, 42);
+		assert.strictEqual(e.col, 7);
+		assert.strictEqual(e.dedup_count, 1, "a lone error accounts for itself");
+		assert.strictEqual(typeof e.ts, "number", "timestamp stamped");
+		let expected = (thrown.stack ?? "").split("\n").map((line) => line.trim()).filter(Boolean);
+		assert.deepEqual(e.stack.split("\n").slice(0, 5), expected.slice(0, 5), "the throw's own frames are carried, trimmed but otherwise verbatim");
+		assert.true(e.top_frame_function.length > 0, "the throwing function is named");
+		assert.true(e.stack.includes(e.top_frame_function), "and it is lifted out of the captured stack");
+	});
+	(0, import_qunit.test)("records a client-error event for an unhandled rejection", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		dispatchRejection(errorWithStack("rejected", ["    at reestablish (https://realm.example/my-realm/store.gts:9:15)", "    at caller (https://realm.example/my-realm/file.gts:3:1)"]));
+		let e = clientErrors(svc)[0];
+		assert.strictEqual(e.kind, "unhandledrejection");
+		assert.strictEqual(e.message, "Error: rejected");
+		assert.strictEqual(e.stack, "Error: rejected\nat reestablish (https://realm.example/my-realm/store.gts:9:15)\nat caller (https://realm.example/my-realm/file.gts:3:1)", "the whole stack rides along, one frame per line");
+		assert.strictEqual(e.top_frame_function, "reestablish");
+		assert.strictEqual(e.source_url, "https://realm.example/my-realm/store.gts", "the throw site is parsed out of the first frame");
+		assert.strictEqual(e.line, 9);
+		assert.strictEqual(e.col, 15);
+		assert.true(capturedExceptions.some((captured) => captured?.message === "rejected"), "the synthetic rejection travelled the real global rejection path");
+	});
+	(0, import_qunit.test)("an error storm reports one event with a count and leaves other signals alone", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		svc.recordEvent({
+			event_type: "card-load",
+			card_id: "https://realm.example/my-realm/Person/1",
+			realm: "https://realm.example/my-realm/",
+			loading_ms: 10,
+			settle_ms: 12,
+			num_loads: 1,
+			loaded_ids: [],
+			slowest_loads: []
+		});
+		let looping = errorWithStack("render loop", frames(3));
+		for (let i = 0; i < 300; i++) dispatchUncaught(looping);
+		let buffered = svc.drainBufferForTest();
+		let errors = buffered.filter((e) => e.event_type === "client-error");
+		assert.strictEqual(errors.length, 1, "300 identical throws, one event");
+		assert.strictEqual(errors[0].dedup_count, 300, "every occurrence is counted on the one event");
+		assert.strictEqual(buffered.filter((e) => e.event_type === "card-load").length, 1, "the storm did not evict the other signal types from the buffer");
+	});
+	(0, import_qunit.test)("distinct errors past the window budget fold into one counted event", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		for (let i = 0; i < 30; i++) dispatchUncaught(errorWithStack(`distinct failure ${i}`, frames(2)));
+		let errors = clientErrors(svc);
+		assert.true(errors.length <= 12, `bounded to the per-window event budget (got ${errors.length})`);
+		assert.strictEqual(errors.reduce((sum, e) => sum + e.dedup_count, 0), 30, "no occurrence is lost — the folded event counts the whole group");
+		let folded = errors.filter((e) => e.folded_signatures > 0);
+		assert.strictEqual(folded.length, 1, "exactly one event is a folded group");
+		assert.true(errors.filter((e) => e.folded_signatures === 0).every((e) => e.dedup_count === 1), "an unfolded event counts occurrences of its own error only");
+	});
+	(0, import_qunit.test)("a folded group counts distinct errors, not occurrences", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		for (let i = 0; i < 11; i++) dispatchUncaught(errorWithStack(`filler ${i}`, frames(2)));
+		let folding = [
+			0,
+			1,
+			2,
+			3
+		].map((i) => errorWithStack(`folded distinct ${i}`, frames(2)));
+		for (let round = 0; round < 25; round++) folding.forEach((error) => dispatchUncaught(error));
+		let folded = clientErrors(svc).filter((e) => e.folded_signatures > 0);
+		assert.strictEqual(folded.length, 1, "one shared slot");
+		assert.strictEqual(folded[0].dedup_count, 100, "its dedup_count is every occurrence it absorbed");
+		assert.strictEqual(folded[0].folded_signatures, 4, "while folded_signatures is the four distinct errors behind them");
+		assert.notStrictEqual(folded[0].folded_signatures, folded[0].dedup_count, "the two must be able to differ, or the field says nothing");
+	});
+	(0, import_qunit.test)("the error channel is dormant until a test opts in", function(assert) {
+		let svc = telemetry();
+		assert.false(svc.isEnabled, "precondition: dormant under isTesting()");
+		dispatchUncaught(/* @__PURE__ */ new Error("should not be recorded"));
+		assert.strictEqual(svc.drainBufferForTest().length, 0, "an uncaught error records nothing while the instrument is off");
+	});
+	(0, import_qunit.test)("the error channel is silent inside a render context", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		svc.drainBufferForTest();
+		let globals = globalThis;
+		let saved = globals.__boxelRenderContext;
+		globals.__boxelRenderContext = true;
+		try {
+			dispatchUncaught(/* @__PURE__ */ new Error("a render that threw"));
+			assert.strictEqual(clientErrors(svc).length, 0, "a throw during a prerender is an indexing outcome, not a client fault");
+		} finally {
+			globals.__boxelRenderContext = saved;
+		}
+	});
+	(0, import_qunit.test)("teardown disarms the instrument and drops further events", function(assert) {
+		let svc = telemetry();
+		svc.enableForTest();
+		assert.true(svc.isEnabled);
+		svc.teardown();
+		assert.false(svc.isEnabled, "disarmed after teardown");
+		svc.recordEvent({
+			event_type: "keepalive",
+			window_ms: 1,
+			max_gap_ms: 0
+		});
+		assert.strictEqual(svc.drainBufferForTest().length, 0, "recordEvent is a no-op once disarmed");
+		dispatchUncaught(/* @__PURE__ */ new Error("after teardown"));
+		assert.strictEqual(svc.drainBufferForTest().length, 0, "the window error listeners are released with everything else");
+	});
+	(0, import_qunit.module)("the correlation id stamp", function() {
+		async function stampedHeader(url) {
+			let svc = telemetry();
+			svc.enableForTest();
+			let middleware = createServerRequestTimingMiddleware(getOwner(svc));
+			let seen = null;
+			await middleware(new Request(url, { method: "POST" }), async (req) => {
+				seen = req.headers.get(X_BOXEL_LOGGING_CORRELATION_ID_HEADER);
+				return new Response("{}", { status: 200 });
+			});
+			return seen;
+		}
+		(0, import_qunit.test)("is put on a realm-server request", async function(assert) {
+			assert.notStrictEqual(await stampedHeader(new URL("my-realm/_search", config.realmServerURL).href), null, "the realm server gets an id to join its logs on");
+		});
+		(0, import_qunit.test)("is kept off a third-party request", async function(assert) {
+			assert.strictEqual(await stampedHeader("https://upload.wikimedia.org/wikipedia/commons/a/a1/logo.svg"), null, "no custom header for a host that never reads it");
+		});
+		(0, import_qunit.test)("is kept off a Matrix request", async function(assert) {
+			assert.strictEqual(await stampedHeader("https://matrix.example/_matrix/client/v3/register/email/requestToken"), null, "no custom header for Synapse to reject at preflight");
+		});
+	});
+});
+//#endregion