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

package/bundled-test-harness/assets/policy-scoped-search-test-BjQRDYqR.js

@@ -1,339 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL, Co as SupportedMimeType, Rc as Deferred } from "./runtime-common-BTaLJEw-.js";
-import { T as rri } from "./paths-C9-NYXnM.js";
-import { O as baseRealm } from "./constants-Icc0nFW-.js";
-import { t as SearchResource } from "./search-C8UKYVZ8.js";
-import { M as waitUntil, T as settled } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { D as realmConfigCardJSON, F as setupLocalIndexing, P as setupIntegrationTestRealm, _t as getRealmServerRoute, lt as setupRenderingTest, t as setupMockMatrix, vt as registerDefaultRoutes, yt as registerRealmServerRoute } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { t as setupCatalogTestSubset } from "./catalog-test-subset-DwqjYkNV.js";
-//#region tests/integration/resources/policy-scoped-search-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var COARSE = testRealmURL;
-var SCOPED = "http://test-realm/scoped/";
-var UNJUDGED = "http://test-realm/unjudged/";
-var USER = "@testuser:localhost";
-var OWNER = "@owner:localhost";
-var SCHEDULE = {
-	module: rri(`${COARSE}schedule`),
-	name: "Schedule"
-};
-var SCHEDULE_MODULE = `
-  import { contains, field, CardDef } from "@cardstack/base/card-api";
-  import StringField from "@cardstack/base/string";
-  import { operation } from "@cardstack/base/operations";
-
-  export class Schedule extends CardDef {
-    @field title = contains(StringField);
-    @field providerId = contains(StringField);
-    @field status = contains(StringField);
-
-    @operation static listOpen = {
-      base: 'query',
-      query: { filter: { on: () => Schedule, eq: { status: 'open' } } },
-    };
-  }
-`;
-var policyRef = {
-	module: rri("@cardstack/catalog/realm-policy/realm-policy"),
-	name: "RealmPolicy"
-};
-var scopedPolicy = { data: {
-	type: "card",
-	attributes: {
-		cardInfo: { name: "Scoped" },
-		rules: [{
-			targetType: SCHEDULE,
-			grants: [{ operation: "read" }, {
-				operation: "listOpen",
-				where: ".providerId == actor()"
-			}]
-		}]
-	},
-	meta: { adoptsFrom: policyRef }
-} };
-function schedule(attributes) {
-	return { data: {
-		type: "card",
-		attributes,
-		meta: { adoptsFrom: SCHEDULE }
-	} };
-}
-var MINE_OPEN = `${SCOPED}schedules/mine-open`;
-var MINE_CLOSED = `${SCOPED}schedules/mine-closed`;
-var THEIRS_OPEN = `${SCOPED}schedules/theirs-open`;
-var COARSE_OPEN = `${COARSE}schedules/open`;
-var OPEN = { filter: {
-	on: SCHEDULE,
-	eq: { status: "open" }
-} };
-(0, import_qunit.module)("Integration | policy-scoped search", function(hooks) {
-	let storeService;
-	setupRenderingTest(hooks);
-	setupCatalogTestSubset(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: USER,
-		activeRealms: [baseRealm.url, COARSE],
-		autostart: true
-	});
-	hooks.beforeEach(async function() {
-		storeService = getService("store");
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: COARSE,
-			contents: {
-				"schedule.gts": SCHEDULE_MODULE,
-				"schedules/open.json": schedule({
-					title: "Coarse open",
-					providerId: OWNER,
-					status: "open"
-				}),
-				"schedules/closed.json": schedule({
-					title: "Coarse closed",
-					providerId: OWNER,
-					status: "closed"
-				})
-			}
-		});
-	});
-	async function setupScoped(userPermissions = []) {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: SCOPED,
-			enforcePermissions: true,
-			permissions: {
-				[USER]: userPermissions,
-				[OWNER]: [
-					"read",
-					"write",
-					"realm-owner"
-				]
-			},
-			contents: {
-				"realm.json": realmConfigCardJSON({
-					name: "Scoped",
-					policy: `${SCOPED}policies/policy`
-				}),
-				"policies/policy.json": scopedPolicy,
-				"schedules/mine-open.json": schedule({
-					title: "Mine open",
-					providerId: USER,
-					status: "open"
-				}),
-				"schedules/mine-closed.json": schedule({
-					title: "Mine closed",
-					providerId: USER,
-					status: "closed"
-				}),
-				"schedules/theirs-open.json": schedule({
-					title: "Theirs open",
-					providerId: OWNER,
-					status: "open"
-				})
-			}
-		});
-	}
-	function liveSearch(owner, query, realms) {
-		return SearchResource.from(owner, () => ({ named: {
-			query,
-			realms,
-			isLive: true,
-			isAutoSaved: false,
-			storeService,
-			owner
-		} }));
-	}
-	function ids(search) {
-		return search.instances.map((instance) => String(instance.id)).sort();
-	}
-	async function createLocally(realmURL, path) {
-		return await storeService.addWithoutPersisting({ data: {
-			type: "card",
-			id: `${realmURL}${path}`,
-			attributes: {
-				title: `Local ${path}`,
-				providerId: USER,
-				status: "open"
-			},
-			meta: { adoptsFrom: SCHEDULE }
-		} });
-	}
-	(0, import_qunit.test)("a matching card of a policy-scoped realm that the server did not return is not merged into the result", async function(assert) {
-		await setupScoped();
-		let theirs = await storeService.get(THEIRS_OPEN);
-		assert.strictEqual(theirs.status, "open", "the store holds a card of the scoped realm that matches the query");
-		let search = liveSearch(this.owner, OPEN, [SCOPED, COARSE]);
-		await search.loaded;
-		await settled();
-		assert.deepEqual(search.meta.policyScopedRealms, [SCOPED], "the result marks the realm the user does not read, and only it");
-		assert.deepEqual(ids(search), [COARSE_OPEN], "the result holds only the rows the server returned");
-	});
-	(0, import_qunit.test)("a local create appears in the realm the result does not scope, and not in the realm it does", async function(assert) {
-		await setupScoped();
-		let search = liveSearch(this.owner, OPEN, [SCOPED, COARSE]);
-		await search.loaded;
-		await settled();
-		assert.deepEqual(ids(search), [COARSE_OPEN]);
-		await createLocally(COARSE, "schedules/local");
-		await createLocally(SCOPED, "schedules/local");
-		await settled();
-		assert.deepEqual(ids(search), [`${COARSE}schedules/local`, COARSE_OPEN].sort(), "the create in the realm the user reads is merged, the one in the scoped realm is not");
-	});
-	(0, import_qunit.test)("a local create is not merged into a policy-scoped realm the search names by a registered prefix", async function(assert) {
-		let { virtualNetwork } = getService("network");
-		virtualNetwork.addRealmMapping("@test/scoped/", SCOPED);
-		try {
-			await setupScoped();
-			let search = liveSearch(this.owner, OPEN, ["@test/scoped/", COARSE]);
-			await search.loaded;
-			await settled();
-			assert.deepEqual(search.meta.policyScopedRealms, [SCOPED]);
-			assert.deepEqual(ids(search), [COARSE_OPEN]);
-			await createLocally(COARSE, "schedules/local");
-			await createLocally(SCOPED, "schedules/local");
-			await settled();
-			assert.deepEqual(ids(search), [`${COARSE}schedules/local`, COARSE_OPEN].sort(), "the create in the realm the user reads is merged, the one in the scoped realm is not");
-		} finally {
-			virtualNetwork.removeRealmMapping("@test/scoped/");
-		}
-	});
-	(0, import_qunit.test)("the same local create is merged when the result does not scope its realm", async function(assert) {
-		await setupScoped(["read"]);
-		let search = liveSearch(this.owner, OPEN, [SCOPED, COARSE]);
-		await search.loaded;
-		await settled();
-		assert.strictEqual(search.meta.policyScopedRealms, void 0, "the result marks no realm");
-		await createLocally(SCOPED, "schedules/local");
-		await settled();
-		assert.true(ids(search).includes(`${SCOPED}schedules/local`), "the create is merged into the result");
-	});
-	(0, import_qunit.test)("a local create is merged into a realm the search names by its URL while the store names its cards by prefix", async function(assert) {
-		let { virtualNetwork } = getService("network");
-		virtualNetwork.addRealmMapping("@test/scoped/", SCOPED);
-		try {
-			await setupScoped(["read"]);
-			let search = liveSearch(this.owner, OPEN, [SCOPED, COARSE]);
-			await search.loaded;
-			await settled();
-			let local = await createLocally(SCOPED, "schedules/local");
-			assert.true(String(local.id).startsWith("@test/scoped/"), `the store names the card by prefix: ${local.id}`);
-			await settled();
-			assert.true(ids(search).includes(String(local.id)), "the create is merged into the result");
-		} finally {
-			virtualNetwork.removeRealmMapping("@test/scoped/");
-		}
-	});
-	(0, import_qunit.test)("before the first answer lands, a matching card of a realm the session does not read is not merged", async function(assert) {
-		await setupScoped();
-		await storeService.get(COARSE_OPEN);
-		await storeService.get(THEIRS_OPEN);
-		let answer = getRealmServerRoute(new URL("http://mock/_federated-search"));
-		let held = new Deferred();
-		registerRealmServerRoute({
-			path: "/_federated-search",
-			handler: async (req, url, state) => {
-				await held.promise;
-				return await answer.handler(req, url, state);
-			}
-		});
-		try {
-			let search = liveSearch(this.owner, OPEN, [SCOPED, COARSE]);
-			await waitUntil(() => ids(search).includes(COARSE_OPEN), { timeout: 1e4 });
-			assert.deepEqual(ids(search), [COARSE_OPEN], "while the search is in flight, the card of the realm the session reads is merged, and the card of the scoped realm is not");
-			held.fulfill();
-			await search.loaded;
-			await settled();
-			assert.deepEqual(search.meta.policyScopedRealms, [SCOPED], "the answer marks the scoped realm");
-			assert.deepEqual(ids(search), [COARSE_OPEN]);
-		} finally {
-			registerDefaultRoutes();
-		}
-	});
-	(0, import_qunit.test)("after a search fails, a matching card of a realm the session does not read is not merged", async function(assert) {
-		await setupScoped();
-		await storeService.get(COARSE_OPEN);
-		await storeService.get(THEIRS_OPEN);
-		registerRealmServerRoute({
-			path: "/_federated-search",
-			handler: async () => new Response("unavailable", { status: 500 })
-		});
-		try {
-			let search = liveSearch(this.owner, OPEN, [SCOPED, COARSE]);
-			await search.loaded;
-			await settled();
-			assert.strictEqual(search.errors?.length, 1, "the search failed");
-			assert.deepEqual(ids(search), [COARSE_OPEN], "the card of the realm the session reads is merged, and the card of the scoped realm is not");
-		} finally {
-			registerDefaultRoutes();
-		}
-	});
-	(0, import_qunit.test)("a realm the user does not read stays scoped when its search fails", async function(assert) {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: UNJUDGED,
-			enforcePermissions: true,
-			permissions: {
-				[USER]: [],
-				[OWNER]: [
-					"read",
-					"write",
-					"realm-owner"
-				]
-			},
-			contents: {
-				"realm.json": realmConfigCardJSON({
-					name: "Unjudged",
-					policy: `${UNJUDGED}policies/missing`
-				}),
-				"schedules/theirs-open.json": schedule({
-					title: "Unjudged open",
-					providerId: OWNER,
-					status: "open"
-				})
-			}
-		});
-		let search = liveSearch(this.owner, OPEN, [UNJUDGED, COARSE]);
-		await search.loaded;
-		await settled();
-		assert.deepEqual(search.meta.policyScopedRealms, [UNJUDGED], "the result marks the realm that did not answer");
-		assert.deepEqual(ids(search), [COARSE_OPEN]);
-		await createLocally(UNJUDGED, "schedules/local");
-		await settled();
-		assert.deepEqual(ids(search), [COARSE_OPEN], "a matching local create in that realm is not merged");
-	});
-	(0, import_qunit.test)("a row a policy-scoped result returned still drops out when a local edit stops it matching", async function(assert) {
-		await setupScoped();
-		let served = await storeService.searchEntries({
-			operation: "listOpen",
-			on: SCHEDULE,
-			fields: { entry: ["item"] }
-		}, [SCOPED]);
-		assert.deepEqual(served.data.map((entry) => entry.id), [MINE_OPEN], "the server answers with the user's own open schedule, which the grant admits");
-		assert.deepEqual(served.meta.policyScopedRealms, [SCOPED]);
-		registerRealmServerRoute({
-			path: "/_federated-search",
-			handler: async () => new Response(JSON.stringify(served), {
-				status: 200,
-				headers: { "content-type": SupportedMimeType.CardJson }
-			})
-		});
-		try {
-			await storeService.get(THEIRS_OPEN);
-			let mineClosed = await storeService.get(MINE_CLOSED);
-			let search = liveSearch(this.owner, OPEN, [SCOPED]);
-			await search.loaded;
-			await settled();
-			assert.deepEqual(ids(search), [MINE_OPEN], "the returned row is shown, and the matching card the grant withheld is not");
-			let mine = storeService.peek(MINE_OPEN);
-			mine.status = "closed";
-			assert.deepEqual(ids(search), [], "the edited row drops out");
-			mineClosed.status = "open";
-			assert.deepEqual(ids(search), [], "and a card of the scoped realm that a local edit makes match is not added");
-		} finally {
-			registerDefaultRoutes();
-		}
-	});
-});
-//#endregion

package/bundled-test-harness/assets/prerender-file-extract-test-CEU4SaAZ.js

@@ -1,346 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL, Yr as buildToolFunctionNameFromResolvedRef } from "./runtime-common-BTaLJEw-.js";
-import { D as baseRRI, O as baseRealm } from "./constants-Icc0nFW-.js";
-import { M as waitUntil, k as visit } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-//#region tests/acceptance/prerender-file-extract-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)("Acceptance | prerender | file-extract", function(hooks) {
-	setupApplicationTest(hooks);
-	setupLocalIndexing(hooks);
-	setupOnSave(hooks);
-	setupRealmCacheTeardown(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, { loggedInAs: "@testuser:localhost" });
-	const renderPath = (url, renderOptions, nonce = 0) => `/render/${encodeURIComponent(url)}/${nonce}/${encodeURIComponent(JSON.stringify(renderOptions))}/file-extract`;
-	const fileDefCodeRef = (moduleName, name) => ({
-		module: new URL(moduleName, testRealmURL).href,
-		name
-	});
-	const fileURL = (path) => new URL(path, testRealmURL).href;
-	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() {
-		await withCachedRealmSetup(async () => {
-			await setupAcceptanceTestRealm({
-				mockMatrixUtils,
-				contents: {
-					...SYSTEM_CARD_FIXTURE_CONTENTS,
-					"filedef-success.gts": `
-          import { FileDef as BaseFileDef } from "${baseRealm.url}file-api";
-
-          export class SuccessDef extends BaseFileDef {
-            static async extractAttributes(url) {
-              return {
-                url,
-                name: "custom-success",
-                contentType: "text/plain",
-                custom: true,
-              };
-            }
-          }
-        `,
-					"filedef-mismatch.gts": `
-          import {
-            FileDef as BaseFileDef,
-            FileContentMismatchError,
-          } from "${baseRealm.url}file-api";
-
-          export class MismatchDef extends BaseFileDef {
-            static async extractAttributes() {
-              throw new FileContentMismatchError("content mismatch");
-            }
-          }
-        `,
-					"filedef-throws.gts": `
-          import { FileDef as BaseFileDef } from "${baseRealm.url}file-api";
-
-          export class ThrowingDef extends BaseFileDef {
-            static async extractAttributes() {
-              throw new Error("boom");
-            }
-          }
-        `,
-					"filedef-missing.gts": `
-          export const NotFileDef = {};
-        `,
-					"filedef-passthrough.gts": `
-          import { FileDef as BaseFileDef } from "${baseRealm.url}file-api";
-
-          // Inherits the base extractAttributes unchanged, so it exercises the
-          // base hash/size handling (including the provided-options shortcut).
-          export class PassthroughDef extends BaseFileDef {}
-        `,
-					"greet-tool.ts": `
-          import { Command } from '@cardstack/runtime-common';
-          import { CardDef, field, contains } from "${baseRealm.url}card-api";
-          import StringField from "${baseRealm.url}string";
-
-          export class GreetInput extends CardDef {
-            @field greeting = contains(StringField);
-          }
-
-          export default class GreetCommand extends Command {
-            description = 'Sends a greeting';
-
-            async getInputType() {
-              return GreetInput;
-            }
-
-            async run() {
-              return undefined;
-            }
-          }
-        `,
-					"skills/greeting/SKILL.md": `---
-name: greeting
-description: A skill that greets
-boxel:
-  kind: skill
-  tools:
-    - codeRef:
-        module: ../../greet-tool
-        name: default
-      requiresApproval: false
-    - codeRef:
-        module: '@cardstack/boxel-host/tools/switch-submode'
-        name: default
----
-# Greeting
-
-Greets people.
-`,
-					"skills/broken-tool/SKILL.md": `---
-name: broken-tool
-boxel:
-  kind: skill
-  tools:
-    - codeRef:
-        module: ./missing-tool
-        name: default
-    - codeRef:
-        module: ../../greet-tool
-        name: default
----
-# Broken Tool
-
-One of my tools does not exist.
-`,
-					"recipe.md": `---
-name: pasta
-boxel:
-  kind: recipe
-  tools:
-    - codeRef:
-        module: ../greet-tool
-        name: default
----
-# Pasta
-`,
-					"sample.txt": "hello world",
-					"mismatch.txt": "mismatch content"
-				}
-			});
-		});
-	});
-	hooks.afterEach(function() {
-		delete globalThis.__renderModel;
-	});
-	(0, import_qunit.test)("returns an error when the render model is missing", async function(assert) {
-		let route = this.owner.lookup("route:render/file-extract");
-		route.modelFor = () => void 0;
-		delete globalThis.__renderModel;
-		let result = await route.model({}, {});
-		assert.strictEqual(result.status, "error");
-		assert.ok(result.error, "includes a render error");
-	});
-	(0, import_qunit.test)("returns an error when fileExtract is not enabled", async function(assert) {
-		let route = this.owner.lookup("route:render/file-extract");
-		let aborted = false;
-		let transition = { abort: () => aborted = true };
-		route.modelFor = () => void 0;
-		globalThis.__renderModel = {
-			cardId: fileURL("sample.txt"),
-			nonce: "0",
-			renderOptions: { clearCache: true }
-		};
-		let result = await route.model({}, transition);
-		assert.ok(aborted, "aborts the transition");
-		assert.strictEqual(result.status, "error");
-		assert.ok(result.error, "includes a render error");
-	});
-	(0, import_qunit.test)("uses the provided FileDef to extract attributes", async function(assert) {
-		await visit(renderPath(fileURL("sample.txt"), {
-			fileExtract: true,
-			fileDefCodeRef: fileDefCodeRef("filedef-success", "SuccessDef")
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.true(result.searchDoc?.custom, "uses custom extractor");
-		assert.ok(result.deps.includes(fileDefCodeRef("filedef-success", "SuccessDef").module), "deps include custom file def module");
-	});
-	(0, import_qunit.test)("uses the provided contentHash and contentSize without re-reading the file", async function(assert) {
-		await visit(renderPath(fileURL("sample.txt"), {
-			fileExtract: true,
-			fileDefCodeRef: fileDefCodeRef("filedef-passthrough", "PassthroughDef"),
-			fileContentHash: "sentinel-content-hash",
-			fileContentSize: 4242
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.searchDoc?.contentHash, "sentinel-content-hash", "uses the provided content hash instead of recomputing it");
-		assert.strictEqual(result.searchDoc?.contentSize, 4242, "uses the provided content size instead of re-reading the file");
-	});
-	(0, import_qunit.test)("stamps the provided timestamps onto the resource meta", async function(assert) {
-		await visit(renderPath(fileURL("sample.txt"), {
-			fileExtract: true,
-			fileDefCodeRef: fileDefCodeRef("filedef-success", "SuccessDef"),
-			fileLastModified: 1633516195,
-			fileCreatedAt: 1537321980
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.resource?.meta.lastModified, 1633516195, "the provided lastModified lands in meta");
-		assert.strictEqual(result.resource?.meta.resourceCreatedAt, 1537321980, "the provided createdAt lands in meta as resourceCreatedAt");
-	});
-	(0, import_qunit.test)("reads the timestamps off the file response when none are provided", async function(assert) {
-		await visit(renderPath(fileURL("sample.txt"), {
-			fileExtract: true,
-			fileDefCodeRef: fileDefCodeRef("filedef-passthrough", "PassthroughDef")
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(typeof result.resource?.meta.lastModified, "number", "lastModified is read off the file response");
-	});
-	(0, import_qunit.test)("falls back when the FileDef module is missing extractAttributes", async function(assert) {
-		await visit(renderPath(fileURL("sample.txt"), {
-			fileExtract: true,
-			fileDefCodeRef: fileDefCodeRef("filedef-missing", "MissingDef")
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.searchDoc?.name, "sample.txt");
-		assert.ok(result.error, "includes the original extraction error");
-	});
-	(0, import_qunit.test)("falls back and marks mismatch when the extractor signals a content mismatch", async function(assert) {
-		await visit(renderPath(fileURL("mismatch.txt"), {
-			fileExtract: true,
-			fileDefCodeRef: fileDefCodeRef("filedef-mismatch", "MismatchDef")
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.true(result.mismatch, "sets mismatch flag");
-		assert.ok(result.error, "includes the original extraction error");
-	});
-	(0, import_qunit.test)("stamps LLM tool definitions onto a skill file-meta resource", async function(assert) {
-		await visit(renderPath(fileURL("skills/greeting/SKILL.md"), {
-			fileExtract: true,
-			fileDefCodeRef: {
-				module: baseRRI("markdown-file-def"),
-				name: "MarkdownDef"
-			}
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.frontmatterDiagnostics, void 0, "no frontmatter diagnostics");
-		let tools = result.resource?.attributes?.frontmatter?.tools;
-		assert.strictEqual(tools?.length, 2, "both tools are stamped");
-		let realmToolModule = fileURL("greet-tool");
-		let expectedRealmFn = buildToolFunctionNameFromResolvedRef({
-			module: realmToolModule,
-			name: "default"
-		});
-		let [realmTool, hostTool] = tools;
-		assert.strictEqual(realmTool.codeRef.module, realmToolModule, "relative tool module is resolved absolute against the skill URL");
-		assert.strictEqual(realmTool.codeRef.name, "default");
-		assert.strictEqual(realmTool.functionName, expectedRealmFn);
-		assert.false(realmTool.requiresApproval, "authored false is preserved");
-		assert.strictEqual(realmTool.definition.type, "function");
-		assert.strictEqual(realmTool.definition.function.name, expectedRealmFn);
-		assert.strictEqual(realmTool.definition.function.description, "Sends a greeting");
-		assert.ok(realmTool.definition.function.parameters.properties.attributes.properties.greeting, "generated schema carries the input card fields");
-		let hostToolModule = "@cardstack/boxel-host/tools/switch-submode";
-		assert.strictEqual(hostTool.codeRef.module, hostToolModule, "package specifier passes through verbatim");
-		assert.strictEqual(hostTool.functionName, buildToolFunctionNameFromResolvedRef({
-			module: hostToolModule,
-			name: "default"
-		}));
-		assert.true(hostTool.requiresApproval, "absent requiresApproval stamps as true");
-		assert.ok(hostTool.definition.function.parameters.properties.attributes.properties.submode, "host tool schema carries its input card fields");
-		let searchDocTools = result.searchDoc?.frontmatter?.tools;
-		assert.strictEqual(searchDocTools?.[0]?.codeRef?.module, "../../greet-tool", "search doc keeps the tools as authored");
-		assert.false("definition" in searchDocTools[0], "generated schemas stay out of the search doc");
-		assert.false("functionName" in searchDocTools[0], "stamped functionName stays out of the search doc");
-		assert.ok(result.deps.includes(realmToolModule), "realm-hosted tool module is a runtime dependency of the extract");
-	});
-	(0, import_qunit.test)("a broken tool ref indexes the remaining tools and reports a tool schema error", async function(assert) {
-		await visit(renderPath(fileURL("skills/broken-tool/SKILL.md"), {
-			fileExtract: true,
-			fileDefCodeRef: {
-				module: baseRRI("markdown-file-def"),
-				name: "MarkdownDef"
-			}
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready", "extract still succeeds");
-		let toolSchemaErrors = result.frontmatterDiagnostics?.toolSchemaErrors;
-		assert.strictEqual(toolSchemaErrors?.length, 1);
-		let [toolError] = toolSchemaErrors;
-		assert.strictEqual(toolError.module, fileURL("skills/broken-tool/missing-tool"), "error names the resolved module");
-		assert.strictEqual(toolError.name, "default");
-		assert.ok(toolError.message, "error carries a message");
-		let tools = result.resource?.attributes?.frontmatter?.tools;
-		assert.strictEqual(tools?.length, 2, "both tools stay in the list");
-		assert.strictEqual(tools[0].codeRef.module, "./missing-tool", "failed tool entry stays as authored");
-		assert.strictEqual(tools[0].definition, void 0, "failed tool entry has no schema");
-		assert.ok(tools[1].definition, "the remaining tool still enriches");
-		assert.strictEqual(tools[1].functionName, buildToolFunctionNameFromResolvedRef({
-			module: fileURL("greet-tool"),
-			name: "default"
-		}));
-	});
-	(0, import_qunit.test)("a non-skill markdown file is not enriched even when it declares tools", async function(assert) {
-		await visit(renderPath(fileURL("recipe.md"), {
-			fileExtract: true,
-			fileDefCodeRef: {
-				module: baseRRI("markdown-file-def"),
-				name: "MarkdownDef"
-			}
-		}));
-		let result = await captureFileExtractResult("ready");
-		assert.strictEqual(result.status, "ready");
-		assert.strictEqual(result.frontmatterDiagnostics, void 0, "no frontmatter diagnostics");
-		let frontmatter = result.resource?.attributes?.frontmatter;
-		assert.strictEqual(frontmatter?.tools, void 0, "no typed tools on a non-skill file");
-		assert.strictEqual(frontmatter?.rawContent?.boxel?.tools?.[0]?.codeRef?.module, "../greet-tool", "raw frontmatter is preserved as authored");
-	});
-	(0, import_qunit.test)("returns an error when the file fetch fails", async function(assert) {
-		await visit(renderPath(fileURL("missing.txt"), { fileExtract: true }));
-		let result = await captureFileExtractResult("error");
-		assert.strictEqual(result.status, "error");
-		assert.ok(result.error, "includes a render error");
-	});
-	(0, import_qunit.test)("blocks saves while file-extract is active", async function(assert) {
-		let renderStore = this.owner.lookup("service:render-store");
-		let savedUrls = [];
-		renderStore._onSave((url) => savedUrls.push(url.href));
-		await visit(renderPath(fileURL("sample.txt"), { fileExtract: true }));
-		let patchResult = await renderStore.patch(fileURL("ModelConfiguration/test-gpt"), { attributes: { modelId: "openai/gpt-5" } });
-		assert.strictEqual(patchResult, void 0, "patch is ignored during file-extract render context");
-		assert.deepEqual(savedUrls, [], "does not emit save events");
-		renderStore._unregisterSaveSubscriber();
-	});
-});
-//#endregion