@cardstack/boxel-cli 0.12.0 → 0.13.0-unstable.0

package/bundled-test-harness/assets/presence-BKkR2au7.js

@@ -0,0 +1,553 @@
+import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { et as tracked, kn as isDestroying, wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { o as VOLATILE_TAG, u as consumeTag } from "./validator-T25d_ucg.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
+import "./tracking-CNiq91Pk.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { o as snapshotOnRender, v as postRender, yt as frame } from "./layout-group-BS0gklZp.js";
+import { a as seatOf, i as seatInsets, n as flushPendingMounts, t as MotionNode } from "./node-BWOLCOMI.js";
+import { i as keepAsMemory, o as readShown, r as elementsOf, s as shownOnCopy } from "./memory-B73-H_Rp.js";
+//#region ../glimmer-motion/src/snapshot.ts
+/**
+* `<Presence @mode="snapshot">`: a leaver's exit played on a static copy of
+* it that the engine owns, instead of on its live block.
+*
+* A Glimmer block re-runs from live state for as long as it is rendered, so a
+* leaver kept on screen for its exit shows state that has already moved on.
+* In snapshot mode the leaver's block is torn down in the render that removes
+* it, as if no <Presence> were there. Before that render patches the
+* leaver's block, the element is copied as it stands. After it, the copy goes
+* back where the element stood (before the first node that followed it and is
+* still there), lifted out of flow at its recorded seat, plays the element's
+* exit, and is removed.
+*
+* The seat is read in every frame that follows a render, and whenever the
+* element or the box it is pinned inside resizes, not at the diff: Glimmer
+* patches the DOM in template order, so by the time <Presence> diffs, content
+* earlier in the template has already been patched for the render, and may
+* have moved or resized the element. Its content is still the last frame's;
+* its box may not be. A move that is neither a render nor one of those
+* resizes is not seen: a transition on a sibling's width can shift the
+* element without resizing either box, and the copy is then pinned where the
+* element stood before that move.
+*
+* The copy is kept as a memory (see memory.ts): it shows the element's last
+* frame, and nothing in it acts. A clone does not carry everything the
+* element showed, so the copy also takes the canvas pixels it showed, the
+* option each of its selects had chosen, and the values its script
+* animations and transitions had reached.
+*/
+/** where a copy is pinned, and what its exit variants resolve against */
+/** what the diff read from a leaver, for its copy to use after the render */
+var copyId = 0;
+/** an element's CSS property for a keyframe key: `clipPath` → `clip-path`, `--x` stays */
+function cssProperty(key) {
+	if (key.startsWith("--")) return key;
+	return key === "cssFloat" ? "float" : key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+var KEYFRAME_META = new Set([
+	"composite",
+	"computedOffset",
+	"easing",
+	"offset"
+]);
+/** a script animation or a transition: the copy keeps the value it shows now */
+function freezeComputed(animation, live, copy) {
+	const effect = animation.effect;
+	const computed = getComputedStyle(live);
+	const style = copy.style;
+	for (const frame of effect.getKeyframes()) for (const key of Object.keys(frame)) if (!KEYFRAME_META.has(key)) {
+		const property = cssProperty(key);
+		style.setProperty(property, computed.getPropertyValue(property));
+	}
+}
+function copyCanvas(live, copy) {
+	try {
+		copy.getContext("2d")?.drawImage(live, 0, 0);
+	} catch {}
+}
+/**
+* Copies an element that is about to be removed, as it stands. Called from
+* <Presence>'s diff, before the render patches the element's block. `seat` is
+* the one recorded for it (see MotionNode.recordSeat); an element that is
+* leaving before any seat was recorded is pinned where it stands now.
+*/
+function captureExit(source) {
+	const { element, props } = source;
+	const parent = element.parentNode;
+	const seat = source.seat ?? seatOf(element);
+	if (!parent || !seat) return;
+	const copy = element.cloneNode(true);
+	const live = elementsOf(element);
+	const copies = elementsOf(copy);
+	const indexOf = new Map(live.map((el, i) => [el, i]));
+	for (const animation of element.getAnimations({ subtree: true })) {
+		const effect = animation.effect;
+		const index = !(animation instanceof CSSAnimation) && effect instanceof KeyframeEffect && !effect.pseudoElement && effect.target ? indexOf.get(effect.target) : void 0;
+		if (index !== void 0) freezeComputed(animation, live[index], copies[index]);
+	}
+	live.forEach((el, i) => {
+		if (el instanceof HTMLCanvasElement) copyCanvas(el, copies[i]);
+		else if (el instanceof HTMLOptionElement) copies[i].selected = el.selected;
+	});
+	const following = [];
+	for (let node = element.nextSibling; node; node = node.nextSibling) following.push(node);
+	return new ExitCopy({
+		copy,
+		following,
+		parent,
+		props,
+		seat,
+		shown: shownOnCopy(readShown(element), element, copy)
+	});
+}
+/** one static copy of a leaver, from the render that removed the leaver until its exit ends */
+var ExitCopy = class {
+	node;
+	ended = false;
+	/** set once the copy has mounted and its exit has started: before that, a report is the mount's */
+	armed = false;
+	reports = /* @__PURE__ */ new Map();
+	onDone;
+	captured;
+	constructor(captured) {
+		this.captured = captured;
+	}
+	/** after the render: put the copy where its element stood and play the exit */
+	start(placement, onDone) {
+		this.onDone = onDone;
+		const { copy, following, parent, props, shown } = this.captured;
+		if (this.ended || !parent.isConnected) {
+			this.end(true);
+			return;
+		}
+		this.pin(placement);
+		const before = following.find((node) => node.parentNode === parent);
+		keepAsMemory(copy, shown, () => parent.insertBefore(copy, before ?? null));
+		(this.node = new MotionNode()).update(copy, {
+			...props,
+			presence: this.handle(placement)
+		});
+		flushPendingMounts();
+		this.armed = true;
+		this.check();
+	}
+	/** stop now and remove the copy, without reporting an exit (its item came back) */
+	cut() {
+		this.end(false);
+	}
+	/** lifted out of flow at the seat its element had: inline and important, so the copy's own CSS cannot move it */
+	pin({ anchorX, anchorY }) {
+		const { copy, seat } = this.captured;
+		const { inline, block } = seatInsets(seat, anchorX, anchorY);
+		const style = copy.style;
+		const set = (property, value) => style.setProperty(property, value, "important");
+		set("position", "absolute");
+		set("margin", "0");
+		set("width", `${seat.w}px`);
+		set("height", `${seat.h}px`);
+		for (const side of [
+			"top",
+			"right",
+			"bottom",
+			"left"
+		]) set(side, "auto");
+		set(inline[0], `${inline[1]}px`);
+		set(block[0], `${block[1]}px`);
+	}
+	/** the copy is not present, and its exit is done once every motion element registered in it reports */
+	handle(placement) {
+		const id = `presence-copy-${copyId++}`;
+		const context = {
+			id,
+			isPresent: false,
+			custom: placement.custom,
+			register: (childId) => {
+				this.reports.set(childId, false);
+				return () => {
+					this.reports.delete(childId);
+					this.check();
+				};
+			},
+			onExitComplete: (childId) => {
+				this.reports.set(childId, true);
+				this.check();
+			}
+		};
+		return {
+			anchorX: placement.anchorX,
+			anchorY: placement.anchorY,
+			context,
+			isPresent: false,
+			key: id,
+			mode: "sync",
+			popCandidate: () => () => void 0,
+			subscribe: () => () => void 0
+		};
+	}
+	check() {
+		if (this.armed && !this.ended && [...this.reports.values()].every(Boolean)) this.end(true);
+	}
+	end(report) {
+		if (this.ended) return;
+		this.ended = true;
+		this.node?.destroy();
+		this.node = void 0;
+		this.captured.copy.remove();
+		if (report) this.onDone?.();
+	}
+};
+//#endregion
+//#region ../glimmer-motion/src/presence.gts
+/**
+* AnimatePresence for Glimmer — the same algorithm as Motion's
+* components/AnimatePresence (diff present vs rendered, keep leavers until
+* every exit inside them completes, `exitComplete` map, mode="wait", custom,
+* onExitComplete, propagate).
+*
+*   <Presence @items={{this.crumbs}} @key={{this.keyOf}} @mode="popLayout" as |crumb p|>
+*     <span {{motion presence=p initial=… animate=… exit=…}}>…</span>
+*   </Presence>
+*
+* Motion elements nested deeper inside a child inherit its presence through
+* their parent VisualElement, as React's PresenceContext would provide it.
+*
+* `@mode="snapshot"` is this package's own: a leaver's block is torn down in
+* the render that removes it, and a static copy of the element the handle was
+* passed to plays that element's exit, lifted out of flow at the seat the last
+* frame showed the element in. Use it where a leaver's content comes from
+* state that moves on as it leaves, such as a component's blocks: a live
+* leaver would re-render from that state, and stay focusable, with its ids
+* and form controls, beside its replacement. The copy is kept as a memory
+* (see memory.ts). See snapshot.ts.
+*/
+var presence_exports = /* @__PURE__ */ __exportAll({
+	Presence: () => Presence,
+	default: () => Presence
+});
+var presenceId = 0;
+/** PresenceChild: one context per rendered child, tracking the motion elements registered inside it */
+var Entry = class {
+	static {
+		decorateFieldV2(this.prototype, "item", [tracked]);
+	}
+	#item = (initializeDeferredDecorator(this, "item"), void 0);
+	/** last presence seen by the diff — plain state, never read during render tracking */ wasPresent = true;
+	id = `presence-${presenceId++}`;
+	children = /* @__PURE__ */ new Map();
+	subscribers = /* @__PURE__ */ new Set();
+	/** popLayout and snapshot: the direct children, so they can be read before the DOM changes */
+	popCandidates = /* @__PURE__ */ new Set();
+	subscribe(refresh) {
+		this.subscribers.add(refresh);
+		return () => this.subscribers.delete(refresh);
+	}
+	popCandidate(node) {
+		this.popCandidates.add(node);
+		return () => {
+			this.popCandidates.delete(node);
+		};
+	}
+	/** snapshot: each direct child reads its seat now; returns the elements those seats depend on */
+	recordSeats() {
+		const watched = [];
+		this.popCandidates.forEach((node) => watched.push(...node.recordSeat()));
+		return watched;
+	}
+	/** snapshot: static copies of the direct children, taken before the render that removes them */
+	copiesForExit() {
+		const copies = [];
+		this.popCandidates.forEach((node) => {
+			const source = node.exitForCopy();
+			const copy = source && captureExit(source);
+			if (copy) copies.push(copy);
+		});
+		return copies;
+	}
+	key;
+	owner;
+	initialBlocked;
+	constructor(key, item, owner, initialBlocked) {
+		this.key = key;
+		this.item = item;
+		this.owner = owner;
+		this.initialBlocked = initialBlocked;
+	}
+	/** derived from @items (and the parent handle) — nothing is mutated during render */
+	get isPresent() {
+		return this.owner.isKeyPresent(this.key);
+	}
+	get mode() {
+		return this.owner.args.mode ?? "sync";
+	}
+	get anchorX() {
+		return this.owner.args.anchorX ?? "left";
+	}
+	get anchorY() {
+		return this.owner.args.anchorY ?? "top";
+	}
+	get context() {
+		return {
+			id: this.id,
+			isPresent: this.isPresent,
+			initial: this.initialBlocked ? false : void 0,
+			custom: this.owner.args.custom,
+			register: (childId) => {
+				const leaving = !this.isPresent;
+				this.children.set(childId, leaving);
+				if (leaving) postRender(() => this.checkComplete());
+				return () => {
+					this.children.delete(childId);
+					if (!this.isPresent && !this.children.size) this.owner.onExit(this.key);
+				};
+			},
+			onExitComplete: (childId) => {
+				this.children.set(childId, true);
+				this.checkComplete();
+			}
+		};
+	}
+	/** presence flipped (PresenceChild's isPresent effects): children report again; no children → done at once */
+	presenceChanged(present) {
+		if (!present && this.mode === "popLayout") this.popCandidates.forEach((node) => node.measureForPop());
+		this.children.forEach((_, k) => this.children.set(k, false));
+		postRender(() => this.notify());
+		if (!present) postRender(() => this.checkImmediateExit());
+	}
+	notify() {
+		flushPendingMounts();
+		this.subscribers.forEach((fn) => fn());
+	}
+	/** every registered child has reported: the leaver is done */
+	checkComplete() {
+		if (this.isPresent) return;
+		for (const done of this.children.values()) if (!done) return;
+		this.owner.onExit(this.key);
+	}
+	checkImmediateExit() {
+		flushPendingMounts();
+		if (!this.isPresent && !this.children.size) this.owner.onExit(this.key);
+	}
+};
+var Presence = class extends Component {
+	entries = /* @__PURE__ */ new Map();
+	order = [];
+	lastItems;
+	firstRender = true;
+	/** React's exitComplete map + exitingComponents set */
+	exitComplete = /* @__PURE__ */ new Map();
+	exiting = /* @__PURE__ */ new Set();
+	pendingItems = [];
+	registeredWithParent;
+	selfId = `presence:${presenceId++}`;
+	/** snapshot: copies still playing an exit, by the key of the item they copied */
+	copies = /* @__PURE__ */ new Map();
+	/** snapshot: a read of the children's seats is booked for the next frame */
+	seatReadBooked = false;
+	/** snapshot: re-reads the seats when a child, or the box it is pinned inside, resizes */
+	resizes;
+	watched = /* @__PURE__ */ new Set();
+	static {
+		decorateFieldV2(this.prototype, "version", [tracked], function() {
+			return 0;
+		});
+	}
+	#version = (initializeDeferredDecorator(this, "version"), void 0);
+	constructor(owner, args) {
+		super(owner, args);
+		registerDestructor(this, () => {
+			this.registeredWithParent?.();
+			this.copies.forEach((_, copy) => copy.cut());
+			this.copies.clear();
+			this.stopWatchingSeats();
+		});
+	}
+	get parentPresent() {
+		const { propagate, parent } = this.args;
+		return !propagate || !parent || parent.isPresent;
+	}
+	/** the keys @items currently asks for (empty while a propagating parent is leaving) */
+	get presentKeys() {
+		return this.parentPresent ? this.args.items.map(this.args.key) : [];
+	}
+	isKeyPresent(key) {
+		return this.presentKeys.includes(key);
+	}
+	/**
+	* Snapshot: a leaver's copy is pinned to the seat its element last
+	* recorded. Each direct child reads its seat in the frame after every
+	* render, and again whenever it or the box it is pinned inside resizes (see
+	* MotionNode.recordSeat). The diff cannot read it: Glimmer patches the DOM
+	* in template order, so content earlier in the template than this
+	* <Presence> has been patched by the time it diffs, and may have moved or
+	* resized the leaver. A move that is neither a render nor one of those
+	* resizes, such as a transition on a sibling's width, is not seen.
+	*/
+	get seatWatch() {
+		if (this.args.mode !== "snapshot") {
+			this.stopWatchingSeats();
+			return;
+		}
+		consumeTag(VOLATILE_TAG);
+		if (!this.seatReadBooked) {
+			this.seatReadBooked = true;
+			frame.read(() => {
+				this.seatReadBooked = false;
+				this.readSeats();
+			});
+		}
+	}
+	/**
+	* Reads every child's seat. After a render it also moves the resize watch
+	* onto the elements those seats depend on now; a read from the watch itself
+	* leaves it alone, since a target observed inside a resize callback can be
+	* left undelivered, which the browser reports as an error.
+	*/
+	readSeats(rewatch = true) {
+		if (isDestroying(this) || this.args.mode !== "snapshot") return;
+		const watched = /* @__PURE__ */ new Set();
+		this.entries.forEach((e) => e.recordSeats().forEach((el) => watched.add(el)));
+		if (!rewatch) return;
+		const resizes = this.resizes ??= new ResizeObserver(() => this.readSeats(false));
+		this.watched.forEach((el) => {
+			if (!watched.has(el)) resizes.unobserve(el);
+		});
+		watched.forEach((el) => {
+			if (!this.watched.has(el)) resizes.observe(el);
+		});
+		this.watched = watched;
+	}
+	stopWatchingSeats() {
+		this.resizes?.disconnect();
+		this.resizes = void 0;
+		this.watched.clear();
+	}
+	get rendered() {
+		this.version;
+		const items = this.args.items;
+		const parentPresent = this.parentPresent;
+		if (this.args.propagate && this.args.parent && !this.registeredWithParent) this.registeredWithParent = this.args.parent.context.register(this.selfId);
+		if (items !== this.lastItems || this.lastParentPresent !== parentPresent) {
+			snapshotOnRender();
+			this.lastItems = items;
+			this.lastParentPresent = parentPresent;
+			this.pendingItems = items;
+			const presentKeys = this.presentKeys;
+			const blockInitial = this.firstRender && this.args.initial === false;
+			const snapshot = this.args.mode === "snapshot";
+			items.forEach((item) => {
+				const k = this.args.key(item);
+				const e = this.entries.get(k);
+				if (e) e.item = item;
+				else {
+					this.cutCopies(k);
+					this.entries.set(k, new Entry(k, item, this, blockInitial));
+				}
+			});
+			const exitingKeys = [];
+			const copied = [];
+			let snapshotLeft = false;
+			let next = parentPresent ? [...presentKeys] : [];
+			let insertionIndex = 0;
+			for (const k of this.order) {
+				const presentIndex = presentKeys.indexOf(k);
+				if (presentIndex === -1 && snapshot) {
+					snapshotLeft = true;
+					for (const copy of this.entries.get(k)?.copiesForExit() ?? []) {
+						this.copies.set(copy, k);
+						copied.push(copy);
+					}
+					this.entries.delete(k);
+					this.exitComplete.delete(k);
+					this.exiting.delete(k);
+				} else if (presentIndex === -1) {
+					next.splice(insertionIndex++, 0, k);
+					exitingKeys.push(k);
+				} else insertionIndex = presentIndex + exitingKeys.length + 1;
+			}
+			if (snapshotLeft) postRender(() => this.startCopies(copied));
+			if ((this.args.mode ?? "sync") === "wait" && exitingKeys.length) next = exitingKeys;
+			this.order = next.filter((k, i) => next.indexOf(k) === i);
+			for (const k of this.order) {
+				const e = this.entries.get(k);
+				const present = presentKeys.includes(k);
+				if (!present) {
+					if (this.exitComplete.get(k) !== true) this.exitComplete.set(k, false);
+				} else {
+					this.exitComplete.delete(k);
+					this.exiting.delete(k);
+				}
+				if (e.wasPresent !== present) {
+					e.wasPresent = present;
+					e.presenceChanged(present);
+				}
+			}
+			this.firstRender = false;
+			if (this.args.propagate && !parentPresent && !this.order.length && !snapshotLeft && !this.copies.size) postRender(() => this.safeToRemove());
+		}
+		return this.order.map((k) => this.entries.get(k));
+	}
+	lastParentPresent;
+	/** AnimatePresence's onExit for one child: once every exiting child is done, show what's pending */
+	onExit(key) {
+		if (this.exiting.has(key)) return;
+		if (!this.exitComplete.has(key)) return;
+		this.exiting.add(key);
+		this.exitComplete.set(key, true);
+		for (const done of this.exitComplete.values()) if (!done) return;
+		const presentKeys = this.parentPresent ? this.pendingItems.map(this.args.key) : [];
+		for (const k of this.order) if (!presentKeys.includes(k)) this.entries.delete(k);
+		this.lastItems = void 0;
+		this.exitComplete.clear();
+		this.exiting.clear();
+		this.order = presentKeys;
+		this.version++;
+		if (this.args.propagate) this.safeToRemove();
+		this.args.onExitComplete?.();
+	}
+	safeToRemove() {
+		this.args.parent?.context.onExitComplete?.(this.selfId);
+	}
+	/** snapshot: after the render that removed their items, the copies go back in and play their exits */
+	startCopies(copies) {
+		const placement = {
+			anchorX: this.args.anchorX ?? "left",
+			anchorY: this.args.anchorY ?? "top",
+			custom: this.args.custom
+		};
+		for (const copy of copies) if (this.copies.has(copy)) copy.start(placement, () => this.copyLeft(copy));
+		if (!copies.length) this.checkCopiesLeft();
+	}
+	copyLeft(copy) {
+		this.copies.delete(copy);
+		this.checkCopiesLeft();
+	}
+	/** every copy has finished its exit, and no live leaver is still playing one: report as onExit does */
+	checkCopiesLeft() {
+		if (this.copies.size || this.exitComplete.size || isDestroying(this)) return;
+		if (this.args.propagate) this.safeToRemove();
+		this.args.onExitComplete?.();
+	}
+	cutCopies(key) {
+		this.copies.forEach((k, copy) => {
+			if (k === key) {
+				this.copies.delete(copy);
+				copy.cut();
+			}
+		});
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "OVg7Gi4X",
+			"block": "[[[1,[30,0,[\"seatWatch\"]]],[1,\"\\n\"],[42,[28,[31,1],[[28,[31,1],[[30,0,[\"rendered\"]]],null]],null],\"key\",[[[1,\"  \"],[18,2,[[30,1,[\"item\"]],[30,1]]],[1,\"\\n\"]],[1]],null]],[\"e\",\"&default\"],[\"each\",\"-track-array\",\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/glimmer-motion/src/presence.gts",
+			"isStrictMode": true
+		}), this);
+	}
+};
+//#endregion
+export { presence_exports as n, Presence as t };

package/bundled-test-harness/assets/presence-CcEXVges.js

@@ -0,0 +1,2 @@
+import { t as Presence } from "./presence-BKkR2au7.js";
+export { Presence, Presence as default };

package/bundled-test-harness/assets/{quick-look-test-VW5_W7dm.js → quick-look-test-BrnxRRsq.js}

@@ -6,7 +6,7 @@ import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
 import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-XSX5809v.js";
+import { t as OperatorModeContainer } from "./container-CXZoEvul.js";
 import { c as triggerKeyEvent, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-Ci72h1Wf.js";

package/bundled-test-harness/assets/{realm-api-keys-sg--fohv.js → realm-api-keys-CHPnfcko.js}

@@ -18,7 +18,7 @@ import { a as ListRealmKeySharesTool, r as SuspendKeyShareTool, s as GetKeyShare
 import { t as OpenSecureWindowTool } from "./open-secure-window-DLIotnK5.js";
 import { t as Button } from "./button-CXBgG9uE.js";
 import { c as listenDocumentCapture, s as listenDocument } from "./focus-Dmgc0c-7.js";
-import { t as Chip } from "./chip-BydgljDL.js";
+import { t as Chip } from "./chip-DVJE_YDh.js";
 import { a as resolvePlacement, i as resolveOpen, n as anchorTo } from "./overlay-C5k_NSQJ.js";
 import { t as isLiveRender } from "./render-context-CZy_0gyC.js";
 //#region ../boxel-icons/dist/@cardstack/boxel-icons/v1/icons/key.js

package/bundled-test-harness/assets/realm-api-keys-GLBmvu4U.js

@@ -0,0 +1,2 @@
+import { t as RealmApiKeys } from "./realm-api-keys-CHPnfcko.js";
+export { RealmApiKeys as default };

package/bundled-test-harness/assets/{realm-api-keys-test-Cy7qSoAd.js → realm-api-keys-test-CHBGOFcx.js}

@@ -6,7 +6,7 @@ import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
 import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-XSX5809v.js";
+import { t as OperatorModeContainer } from "./container-CXZoEvul.js";
 import { T as settled, o as waitFor } from "./dist-BOAdzfkP.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { D as realmConfigCardJSON, F as setupLocalIndexing, P as setupIntegrationTestRealm, St as unregisterRealmServerRoute, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix, yt as registerRealmServerRoute } from "./mock-matrix-Ci72h1Wf.js";

package/bundled-test-harness/assets/{realm-config-DvpP1xf-.js → realm-config-C7c3B2er.js}

@@ -35,7 +35,7 @@ import { t as NumberField } from "./number-BhzcQBKm.js";
 import { t as isLiveRender } from "./render-context-CZy_0gyC.js";
 import { t as JsonField } from "./json-field-BWYU9trX.js";
 import { d as operations, u as operation } from "./operations-BTFC1cvX.js";
-import { t as RealmApiKeys } from "./realm-api-keys-sg--fohv.js";
+import { t as RealmApiKeys } from "./realm-api-keys-CHPnfcko.js";
 //#region ../base/realm-config.gts
 var RoutingRuleAtom = class extends Component$1 {
 	static {

package/bundled-test-harness/assets/{realm-config-policy-standing-test-DJk-ftgH.js → realm-config-policy-standing-test-C8aNeb6_.js}

@@ -7,7 +7,7 @@ import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
 import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-XSX5809v.js";
+import { t as OperatorModeContainer } from "./container-CXZoEvul.js";
 import { T as settled, d as click, m as rerender, o as waitFor } from "./dist-BOAdzfkP.js";
 import { n as ISOLATED_RENDER_ELEMENT_ID } from "./render-service-DONRC3JB.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";

package/bundled-test-harness/assets/{realm-config-routing-rule-edit-test-CTPiJrAL.js → realm-config-routing-rule-edit-test-Dmnw-VQz.js}

@@ -7,7 +7,7 @@ import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
 import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-XSX5809v.js";
+import { t as OperatorModeContainer } from "./container-CXZoEvul.js";
 import { T as settled, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, nt as provide, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-Ci72h1Wf.js";

package/bundled-test-harness/assets/{realm-config-settings-test-CUa-PjMC.js → realm-config-settings-test-C6V0Mx35.js}

@@ -6,7 +6,7 @@ import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
 import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-XSX5809v.js";
+import { t as OperatorModeContainer } from "./container-CXZoEvul.js";
 import { M as waitUntil, d as click, l as triggerEvent, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-Ci72h1Wf.js";

package/bundled-test-harness/assets/{reasoning-test-CeeGGwvf.js → reasoning-test-Dn0Xb42V.js}

@@ -6,7 +6,7 @@ import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
 import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
-import { t as OperatorModeContainer } from "./container-XSX5809v.js";
+import { t as OperatorModeContainer } from "./container-CXZoEvul.js";
 import { M as waitUntil, T as settled, d as click, o as waitFor } from "./dist-BOAdzfkP.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-Ci72h1Wf.js";

package/bundled-test-harness/assets/{rendered-markdown-B8TH0yN4.js → rendered-markdown-DPEXS7MQ.js}

@@ -20,7 +20,7 @@ import { r as modifier, t as ClassBasedModifier } from "./dist-nMt-N14r.js";
 import { t as consume } from "./dist-Ble0L9o7.js";
 import { t as CardRenderer } from "./card-renderer-BxpiPOZ6.js";
 import { a as markdownToHtml, i as markdownOversizedNoticeHtml, r as isMarkdownOverRenderLimit } from "./marked-sync-C-diBz5n.js";
-import { s as beacon } from "./src-BDDYD1rs.js";
+import { s as beacon } from "./src-D8bpj2tb.js";
 import { t as cardRefLabel } from "./reply-furniture-Cu7OoDDn.js";
 //#region app/components/operator-mode/preview-panel/rendered-markdown.gts
 function resolveUrl(raw, baseUrl) {

package/bundled-test-harness/assets/{rendered-markdown-test-CBRsIBqW.js → rendered-markdown-test-DxbJ1nFX.js}

@@ -8,7 +8,7 @@ import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
 import { M as waitUntil, T as settled } from "./dist-BOAdzfkP.js";
-import { t as RenderedMarkdown } from "./rendered-markdown-B8TH0yN4.js";
+import { t as RenderedMarkdown } from "./rendered-markdown-DPEXS7MQ.js";
 import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
 import { lt as setupRenderingTest } from "./mock-matrix-Ci72h1Wf.js";
 import { n as renderComponent } from "./render-component-B15Z0e2v.js";

package/bundled-test-harness/assets/{room-message-test-BTxZ_W74.js → room-message-test-BBE8UIPX.js}

@@ -9,7 +9,7 @@ import "./component-BJO47HTh.js";
 import { t as Component } from "./dist-CkA1rgqO.js";
 import "./template-factory-ds9s0u8l.js";
 import { t as templateOnly } from "./template-only-6nVzLWF-.js";
-import { n as aiBotUserId, r as RoomMessage } from "./panel-t9QyU1lY.js";
+import { n as aiBotUserId, r as RoomMessage } from "./panel-CXmB6GMs.js";
 import { n as getCardCollection } from "./card-collection-DROiEsNV.js";
 import { n as getCard } from "./card-resource-BF1P-sI3.js";
 import { r as provide } from "./dist-Ble0L9o7.js";