@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/summarize-session-test-BMg54JGF.js

@@ -1,169 +0,0 @@
-import { s as __toESM } from "./chunk-CGdGNDIi.js";
-import { Xn as testRealmInfo, Zn as testRealmURL } from "./runtime-common-C7uLt5dN.js";
-import { t as getOwner } from "./owner-CqZ4C0QN.js";
-import { t as SummarizeSessionCommand } from "./summarize-session-CqSvkuVZ.js";
-import { t as RealmService } from "./realm-Dr4iygv_.js";
-import { t as require_qunit } from "./qunit-2hoQyeAZ.js";
-import { r as getService } from "./dist-BfNSLd0O.js";
-import { A as setupIntegrationTestRealm, N as setupRealmCacheTeardown, P as setupRealmServerEndpoints, j as setupLocalIndexing, q as withCachedRealmSetup, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-DqDbNhEj.js";
-import { mt as setupBaseRealm } from "./base-realm-43wjttN2.js";
-//#region tests/integration/commands/summarize-session-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var StubRealmService = class extends RealmService {
-	get defaultReadableRealm() {
-		return {
-			path: testRealmURL,
-			info: testRealmInfo
-		};
-	}
-};
-(0, import_qunit.module)("Integration | commands | summarize-session", function(hooks) {
-	setupRenderingTest(hooks);
-	setupBaseRealm(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		autostart: true
-	});
-	let { createAndJoinRoom, simulateRemoteMessage } = mockMatrixUtils;
-	setupRealmServerEndpoints(hooks, [{
-		route: "_request-forward",
-		getResponse: async (req) => {
-			const body = await req.json();
-			if (body.url.includes("openrouter.ai/api/v1/chat/completions")) {
-				const requestBody = JSON.parse(body.requestBody);
-				if (requestBody.messages && requestBody.messages.some((msg) => msg.content && msg.content.includes("Please provide a concise summary"))) {
-					const conversationText = requestBody.messages.filter((msg) => msg.role === "user" && !msg.content.includes("Please provide a concise summary")).map((msg) => msg.content).join(" ");
-					let summary = "This conversation focused on general discussion.";
-					if (conversationText.includes("project")) summary = "This conversation focused on project help, specifically creating a new card for a person with name and age fields. The user requested assistance with card creation and field definition.";
-					else if (conversationText.includes("card") && conversationText.includes("file")) summary = "This conversation involved discussing a person card (Hassan) and a pet definition file. The user shared both a Person card and a pet.gts file, then asked for help understanding the structure.";
-					else if (conversationText.includes("error")) throw new Error("OpenRouter API error");
-					return new Response(JSON.stringify({ choices: [{ message: { content: summary } }] }), {
-						status: 200,
-						headers: { "Content-Type": "application/json" }
-					});
-				}
-			}
-			return new Response(JSON.stringify({
-				success: true,
-				data: {
-					id: 123,
-					name: "test"
-				}
-			}), {
-				status: 200,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-	}]);
-	hooks.beforeEach(function() {
-		getOwner(this).register("service:realm", StubRealmService);
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		}));
-	});
-	function createMockSummarizeSessionInput(roomId) {
-		return { roomId };
-	}
-	async function createRoomWithHistory(roomName, messages) {
-		const roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: roomName
-		});
-		for (const message of messages) simulateRemoteMessage(roomId, "@testuser:localhost", {
-			body: message,
-			msgtype: "m.text",
-			format: "org.matrix.custom.html"
-		});
-		await waitForRoomToBeLoaded(roomId);
-		return roomId;
-	}
-	async function waitForRoomToBeLoaded(roomId) {
-		let matrixService = getService("matrix-service");
-		while (!matrixService.roomResourcesCache.has(roomId)) await new Promise((resolve) => setTimeout(resolve, 100));
-	}
-	(0, import_qunit.test)("successfully summarizes a conversation with project help content", async function(assert) {
-		const summarizeCommand = new SummarizeSessionCommand(getService("command-service").commandContext);
-		const input = createMockSummarizeSessionInput(await createRoomWithHistory("Project Help Room", [
-			"Hello, I need help with my project",
-			"I want to create a new card for a person",
-			"The person should have a name and age field"
-		]));
-		const result = await summarizeCommand.execute(input);
-		assert.ok(result, "Command should return a result");
-		assert.ok(result.summary, "Result should have a summary");
-		assert.true(result.summary.includes("project help"), "Summary should mention project help");
-		assert.true(result.summary.includes("card for a person"), "Summary should mention card creation");
-		assert.true(result.summary.includes("name and age field"), "Summary should mention the specific fields");
-	});
-	(0, import_qunit.test)("successfully summarizes a conversation with cards and files", async function(assert) {
-		const summarizeCommand = new SummarizeSessionCommand(getService("command-service").commandContext);
-		const input = createMockSummarizeSessionInput(await createRoomWithHistory("Card Discussion Room", [
-			"I have a person card here",
-			"And here is the pet definition file",
-			"Can you help me understand this structure?"
-		]));
-		const result = await summarizeCommand.execute(input);
-		assert.ok(result, "Command should return a result");
-		assert.ok(result.summary, "Result should have a summary");
-		assert.true(result.summary.includes("person card"), "Summary should mention person card");
-		assert.true(result.summary.includes("pet definition file"), "Summary should mention pet definition file");
-		assert.true(result.summary.includes("structure"), "Summary should mention understanding structure");
-	});
-	(0, import_qunit.test)("handles empty room gracefully", async function(assert) {
-		const summarizeCommand = new SummarizeSessionCommand(getService("command-service").commandContext);
-		const roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "Empty Room"
-		});
-		await waitForRoomToBeLoaded(roomId);
-		const input = createMockSummarizeSessionInput(roomId);
-		const result = await summarizeCommand.execute(input);
-		assert.ok(result, "Command should return a result");
-		assert.notOk(result.summary, "Result should not have a summary");
-	});
-	(0, import_qunit.test)("handles API errors gracefully", async function(assert) {
-		const summarizeCommand = new SummarizeSessionCommand(getService("command-service").commandContext);
-		const input = createMockSummarizeSessionInput(await createRoomWithHistory("Error Room", ["This will cause an error", "Testing error handling"]));
-		try {
-			await summarizeCommand.execute(input);
-			assert.ok(false, "Command should have thrown an error");
-		} catch (error) {
-			assert.ok(error instanceof Error, "Error should be an Error instance");
-			const errorMessage = error.message;
-			assert.true(errorMessage.includes("Failed to generate summary"), "Error message should indicate API failure");
-		}
-	});
-	(0, import_qunit.test)("handles room not found gracefully", async function(assert) {
-		const summarizeCommand = new SummarizeSessionCommand(getService("command-service").commandContext);
-		const input = createMockSummarizeSessionInput("non-existent-room-id");
-		try {
-			await summarizeCommand.execute(input);
-			assert.ok(false, "Command should have thrown an error");
-		} catch (error) {
-			assert.ok(error instanceof Error, "Error should be an Error instance");
-			const errorMessage = error.message;
-			assert.true(errorMessage.includes("room"), "Error message should indicate room-related issue");
-		}
-	});
-	(0, import_qunit.test)("includes conversation context in summary request", async function(assert) {
-		const summarizeCommand = new SummarizeSessionCommand(getService("command-service").commandContext);
-		const input = createMockSummarizeSessionInput(await createRoomWithHistory("Context Room", [
-			"User: Hello, I need help with my project",
-			"AI: I can help you with your project. What do you need?",
-			"User: I want to create a new card for a person",
-			"AI: Great! Let me help you create a person card."
-		]));
-		const result = await summarizeCommand.execute(input);
-		assert.ok(result, "Command should return a result");
-		assert.ok(result.summary, "Result should have a summary");
-		assert.true(result.summary.includes("project"), "Summary should include project context");
-		assert.true(result.summary.includes("card for a person"), "Summary should include card creation context");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/svg-image-def-test-xNyIKRPV.js

@@ -1,164 +0,0 @@
-import { s as __toESM } from "./chunk-CGdGNDIi.js";
-import { It as SupportedMimeType, Zn as testRealmURL, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
-import { I as waitUntil, N as visit } from "./dist-D1U_uSwt.js";
-import { t as require_qunit } from "./qunit-2hoQyeAZ.js";
-import { r as getService } from "./dist-BfNSLd0O.js";
-import { D as setupAcceptanceTestRealm, M as setupOnSave, N as setupRealmCacheTeardown, W as waitForLoadedImage, a as SYSTEM_CARD_FIXTURE_CONTENTS, j as setupLocalIndexing, l as capturePrerenderResult, nt as setupApplicationTest, q as withCachedRealmSetup, t as setupMockMatrix } from "./mock-matrix-DqDbNhEj.js";
-import { t as setupTestRealmServiceWorker } from "./test-realm-service-worker-DK4SmTM5.js";
-//#region tests/acceptance/image-def/svg-image-def-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-function makeMinimalSvg(width, height) {
-	return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><rect width="${width}" height="${height}" fill="red"/></svg>`;
-}
-function makeRenderableSvg(width, height) {
-	return [
-		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
-		`<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`,
-		`  <rect x="0" y="0" width="${width}" height="${height}" fill="#ff0000" />`,
-		"</svg>"
-	].join("\n");
-}
-(0, import_qunit.module)("Acceptance | svg image def", function(hooks) {
-	setupApplicationTest(hooks);
-	setupLocalIndexing(hooks);
-	setupOnSave(hooks);
-	setupRealmCacheTeardown(hooks);
-	setupTestRealmServiceWorker(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
-	let realm;
-	const fileExtractPath = (url, renderOptions, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/file-extract`;
-	const fileRenderPath = (url, renderOptions, format = "isolated", ancestorLevel = 0, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/html/${format}/${ancestorLevel}`;
-	const makeFileURL = (path) => new URL(path, testRealmURL).href;
-	const svgDefCodeRef = () => ({
-		module: `${baseRealm.url}svg-image-def`,
-		name: "SvgDef"
-	});
-	async function captureFileExtractResult(expectedStatus) {
-		await waitUntil(() => {
-			let container = document.querySelector("[data-prerender-file-extract]");
-			if (!container) return false;
-			let status = container.getAttribute("data-prerender-file-extract-status");
-			if (!status) return false;
-			if (expectedStatus && status !== expectedStatus) return false;
-			return status === "ready" || status === "error";
-		}, { timeout: 5e3 });
-		let container = document.querySelector("[data-prerender-file-extract]");
-		if (!container) throw new Error("captureFileExtractResult: missing [data-prerender-file-extract] container after wait");
-		let text = container.querySelector("pre")?.textContent?.trim() ?? "";
-		return JSON.parse(text);
-	}
-	hooks.beforeEach(async function() {
-		({realm} = await withCachedRealmSetup(async () => setupAcceptanceTestRealm({
-			mockMatrixUtils,
-			contents: {
-				...SYSTEM_CARD_FIXTURE_CONTENTS,
-				"sample.svg": makeMinimalSvg(120, 80),
-				"renderable.svg": makeRenderableSvg(120, 80),
-				"viewbox-only.svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 200 150\"><circle cx=\"100\" cy=\"75\" r=\"50\"/></svg>",
-				"not-an-svg.svg": "This is plain text, not an SVG file."
-			}
-		})));
-	});
-	hooks.afterEach(function() {
-		delete globalThis.__renderModel;
-		delete globalThis.__boxelFileRenderData;
-	});
-	(0, import_qunit.test)("extracts width and height from SVG with explicit attributes", async function(assert) {
-		await visit(fileExtractPath(makeFileURL("sample.svg"), {
-			fileExtract: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.searchDoc?.width, 120, "extracts SVG width");
-		assert.strictEqual(result.searchDoc?.height, 80, "extracts SVG height");
-		assert.strictEqual(result.searchDoc?.name, "sample.svg");
-		assert.ok(String(result.searchDoc?.contentType).includes("svg"), "sets svg content type");
-	});
-	(0, import_qunit.test)("extracts dimensions from viewBox when width/height attributes are absent", async function(assert) {
-		await visit(fileExtractPath(makeFileURL("viewbox-only.svg"), {
-			fileExtract: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.searchDoc?.width, 200, "extracts width from viewBox");
-		assert.strictEqual(result.searchDoc?.height, 150, "extracts height from viewBox");
-	});
-	(0, import_qunit.test)("falls back when SvgDef is used for non-SVG content", async function(assert) {
-		await visit(fileExtractPath(makeFileURL("not-an-svg.svg"), {
-			fileExtract: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.true(result.mismatch, "marks mismatch when content is not valid SVG");
-		assert.strictEqual(result.searchDoc?.name, "not-an-svg.svg");
-	});
-	(0, import_qunit.test)("isolated template renders img with width and height attributes", async function(assert) {
-		let url = makeFileURL("sample.svg");
-		await visit(fileExtractPath(url, {
-			fileExtract: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.ok(result.resource, "extraction produced a resource");
-		globalThis.__boxelFileRenderData = {
-			resource: result.resource,
-			fileDefCodeRef: svgDefCodeRef()
-		};
-		await visit(fileRenderPath(url, {
-			fileRender: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let { status } = await capturePrerenderResult("innerHTML");
-		assert.strictEqual(status, "ready", "render completed");
-		let img = document.querySelector("[data-prerender] img");
-		assert.ok(img, "img element is rendered");
-		assert.strictEqual(img?.getAttribute("width"), "120", "img has correct width attribute");
-		assert.strictEqual(img?.getAttribute("height"), "80", "img has correct height attribute");
-		assert.ok(img?.getAttribute("src")?.includes("sample.svg"), "img src references the SVG file");
-	});
-	(0, import_qunit.test)("indexing stores SVG metadata and file meta uses it", async function(assert) {
-		let fileURL = new URL("sample.svg", testRealmURL);
-		let fileEntry = await realm.realmIndexQueryEngine.file(fileURL);
-		assert.ok(fileEntry, "file entry exists");
-		assert.strictEqual(fileEntry?.searchDoc?.width, 120, "index stores SVG width");
-		assert.strictEqual(fileEntry?.searchDoc?.height, 80, "index stores SVG height");
-		let response = await getService("network").virtualNetwork.fetch(fileURL, { headers: { Accept: SupportedMimeType.FileMeta } });
-		assert.true(response.ok, "file meta request succeeds");
-		let body = await response.json();
-		assert.strictEqual(body?.data?.type, "file-meta");
-		assert.ok(String(body?.data?.attributes?.contentType).includes("svg"), "file meta uses svg content type");
-		assert.strictEqual(body?.data?.attributes?.width, 120, "file meta includes SVG width");
-		assert.strictEqual(body?.data?.attributes?.height, 80, "file meta includes SVG height");
-		assert.deepEqual(body?.data?.meta?.adoptsFrom, svgDefCodeRef(), "file meta uses SVG def");
-	});
-	(0, import_qunit.test)("authenticated images display in browser", async function(assert) {
-		let url = makeFileURL("renderable.svg");
-		await visit(fileExtractPath(url, {
-			fileExtract: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.ok(result.resource, "extraction produced a resource");
-		globalThis.__boxelFileRenderData = {
-			resource: result.resource,
-			fileDefCodeRef: svgDefCodeRef()
-		};
-		await visit(fileRenderPath(url, {
-			fileRender: true,
-			fileDefCodeRef: svgDefCodeRef()
-		}));
-		let { status } = await capturePrerenderResult("innerHTML");
-		assert.strictEqual(status, "ready", "render completed");
-		let imgSelector = "[data-prerender] .image-isolated__img";
-		let img = document.querySelector(imgSelector);
-		assert.ok(img, "img element is rendered");
-		assert.ok(img?.getAttribute("src")?.includes("renderable.svg"), "img src references the SVG file");
-		let loadedImg = await waitForLoadedImage(imgSelector, { timeout: 1e4 });
-		assert.ok(loadedImg.naturalWidth > 0, "Image loaded successfully with non-zero width");
-		assert.ok(loadedImg.naturalHeight > 0, "Image loaded successfully with non-zero height");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/switch-submode-test-BKvpODUD.js

@@ -1,168 +0,0 @@
-import { s as __toESM } from "./chunk-CGdGNDIi.js";
-import { Di as localId, Xn as testRealmInfo, Zn as testRealmURL } from "./runtime-common-C7uLt5dN.js";
-import { t as getOwner } from "./owner-CqZ4C0QN.js";
-import { t as SwitchSubmodeCommand } from "./switch-submode-BwkCfnCZ.js";
-import { t as RealmService } from "./realm-Dr4iygv_.js";
-import { t as require_qunit } from "./qunit-2hoQyeAZ.js";
-import { r as getService } from "./dist-BfNSLd0O.js";
-import { A as setupIntegrationTestRealm, N as setupRealmCacheTeardown, j as setupLocalIndexing, q as withCachedRealmSetup, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-DqDbNhEj.js";
-import { a as CardDef, mt as setupBaseRealm } from "./base-realm-43wjttN2.js";
-//#region tests/integration/commands/switch-submode-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var store;
-var StubRealmService = class extends RealmService {
-	get defaultReadableRealm() {
-		return {
-			path: testRealmURL,
-			info: testRealmInfo
-		};
-	}
-};
-(0, import_qunit.module)("Integration | commands | switch-submode", function(hooks) {
-	setupRenderingTest(hooks);
-	setupBaseRealm(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		autostart: true
-	});
-	hooks.beforeEach(function() {
-		getOwner(this).register("service:realm", StubRealmService);
-		store = getService("store");
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		}));
-	});
-	(0, import_qunit.test)("switch to code submode by local id of a saved instance", async function(assert) {
-		let instance = await store.add(new CardDef());
-		let commandService = getService("command-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[{
-				id: instance[localId],
-				format: "isolated"
-			}]],
-			submode: "interact"
-		});
-		let switchSubmodeCommand = new SwitchSubmodeCommand(commandService.commandContext);
-		assert.strictEqual(operatorModeStateService.state?.submode, "interact");
-		await switchSubmodeCommand.execute({ submode: "code" });
-		assert.strictEqual(operatorModeStateService.state?.submode, "code");
-		assert.strictEqual(operatorModeStateService.state?.codePath?.href, `${instance.id}.json`);
-	});
-	(0, import_qunit.test)("switch to code submode by remote id of a saved instance", async function(assert) {
-		let instance = await store.add(new CardDef());
-		let commandService = getService("command-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[{
-				id: instance.id,
-				format: "isolated"
-			}]],
-			submode: "interact"
-		});
-		let switchSubmodeCommand = new SwitchSubmodeCommand(commandService.commandContext);
-		assert.strictEqual(operatorModeStateService.state?.submode, "interact");
-		await switchSubmodeCommand.execute({ submode: "code" });
-		assert.strictEqual(operatorModeStateService.state?.submode, "code");
-		assert.strictEqual(operatorModeStateService.state?.codePath?.href, `${instance.id}.json`);
-	});
-	(0, import_qunit.test)("when workspace chooser is open, close it when switching", async function(assert) {
-		let instance = await store.add(new CardDef());
-		let commandService = getService("command-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[{
-				id: instance[localId],
-				format: "isolated"
-			}]],
-			submode: "interact",
-			workspaceChooserOpened: true
-		});
-		let switchSubmodeCommand = new SwitchSubmodeCommand(commandService.commandContext);
-		assert.strictEqual(operatorModeStateService.state?.submode, "interact");
-		assert.true(operatorModeStateService.workspaceChooserOpened);
-		await switchSubmodeCommand.execute({ submode: "code" });
-		assert.strictEqual(operatorModeStateService.state?.submode, "code");
-		assert.false(operatorModeStateService.workspaceChooserOpened, "Workspace chooser should be closed after switching submode");
-	});
-	(0, import_qunit.test)("createFile creates a blank file when it does not exist", async function(assert) {
-		assert.expect(5);
-		let commandService = getService("command-service");
-		let cardService = getService("card-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[]],
-			submode: "interact"
-		});
-		let switchSubmodeCommand = new SwitchSubmodeCommand(commandService.commandContext);
-		let fileUrl = `${testRealmURL}new-file.gts`;
-		let result = await switchSubmodeCommand.execute({
-			submode: "code",
-			codePath: fileUrl,
-			createFile: true
-		});
-		assert.strictEqual(operatorModeStateService.state?.submode, "code");
-		assert.strictEqual(operatorModeStateService.state?.codePath?.href, fileUrl);
-		assert.notOk(result, "no result card when using requested path");
-		let { status, content } = await cardService.getSource(new URL(fileUrl));
-		assert.strictEqual(status, 200);
-		assert.strictEqual(content, "");
-	});
-	(0, import_qunit.test)("createFile picks a non-conflicting filename when the target exists", async function(assert) {
-		assert.expect(5);
-		let commandService = getService("command-service");
-		let cardService = getService("card-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[]],
-			submode: "interact"
-		});
-		let switchSubmodeCommand = new SwitchSubmodeCommand(commandService.commandContext);
-		let fileUrl = `${testRealmURL}existing-file.gts`;
-		let newFileIdentifier = `${testRealmURL}existing-file-1.gts`;
-		await cardService.saveSource(new URL(fileUrl), "existing content", "create-file");
-		let result = await switchSubmodeCommand.execute({
-			submode: "code",
-			codePath: fileUrl,
-			createFile: true
-		});
-		assert.ok(result, "returns a result card with the new filename");
-		assert.strictEqual(result?.codePath, newFileIdentifier);
-		assert.strictEqual(operatorModeStateService.state?.codePath?.href, newFileIdentifier);
-		let { status, content } = await cardService.getSource(new URL(newFileIdentifier));
-		assert.strictEqual(status, 200);
-		assert.strictEqual(content, "");
-	});
-	(0, import_qunit.test)("createFile reuses an existing blank file", async function(assert) {
-		assert.expect(5);
-		let commandService = getService("command-service");
-		let cardService = getService("card-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[]],
-			submode: "interact"
-		});
-		let switchSubmodeCommand = new SwitchSubmodeCommand(commandService.commandContext);
-		let fileUrl = `${testRealmURL}empty-file.gts`;
-		await cardService.saveSource(new URL(fileUrl), "", "create-file");
-		let result = await switchSubmodeCommand.execute({
-			submode: "code",
-			codePath: fileUrl,
-			createFile: true
-		});
-		assert.strictEqual(operatorModeStateService.state?.codePath?.href, fileUrl);
-		assert.notOk(result, "no result card when using existing blank file");
-		let { status, content } = await cardService.getSource(new URL(fileUrl));
-		assert.strictEqual(status, 200);
-		assert.strictEqual(content, "");
-		let nonConflicting = await cardService.getSource(new URL(`${testRealmURL}empty-file-1.gts`));
-		assert.strictEqual(nonConflicting.status, 404);
-	});
-});
-//#endregion

package/bundled-test-harness/assets/test-realm-service-worker-DK4SmTM5.js

@@ -1,73 +0,0 @@
-import "./chunk-CGdGNDIi.js";
-import { r as getService } from "./dist-BfNSLd0O.js";
-//#region tests/helpers/test-realm-service-worker.ts
-var swReady;
-var swRegistration;
-async function ensureRegistered() {
-	if (swReady) return swReady;
-	swReady = (async () => {
-		let reg = await navigator.serviceWorker.register("/test-realm-sw.js");
-		swRegistration = reg;
-		let sw = reg.installing || reg.waiting || reg.active;
-		if (sw && sw.state !== "activated") await new Promise((resolve) => {
-			sw.addEventListener("statechange", function handler() {
-				if (sw.state === "activated") {
-					sw.removeEventListener("statechange", handler);
-					resolve();
-				}
-			});
-		});
-		if (!navigator.serviceWorker.controller) await new Promise((resolve) => {
-			navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true });
-		});
-	})();
-	return swReady;
-}
-function setupTestRealmServiceWorker(hooks) {
-	let handler;
-	hooks.beforeEach(async function() {
-		if (!("serviceWorker" in navigator)) return;
-		await ensureRegistered();
-		let network = getService("network");
-		handler = async (event) => {
-			if (event.data?.type !== "test-realm-fetch") return;
-			let port = event.ports[0];
-			if (!port) return;
-			try {
-				let response = await network.virtualNetwork.fetch(event.data.url);
-				let body = await response.arrayBuffer();
-				let headers = {};
-				response.headers.forEach((v, k) => {
-					headers[k] = v;
-				});
-				port.postMessage({
-					status: response.status,
-					headers,
-					body
-				}, [body]);
-			} catch {
-				port.postMessage({
-					status: 500,
-					headers: {},
-					body: null
-				});
-			}
-		};
-		navigator.serviceWorker.addEventListener("message", handler);
-	});
-	hooks.afterEach(function() {
-		if (handler) {
-			navigator.serviceWorker.removeEventListener("message", handler);
-			handler = void 0;
-		}
-	});
-	hooks.after(async function() {
-		if (swRegistration) {
-			await swRegistration.unregister();
-			swRegistration = void 0;
-			swReady = void 0;
-		}
-	});
-}
-//#endregion
-export { setupTestRealmServiceWorker as t };