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

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

@@ -0,0 +1,339 @@
+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-FjsXmU7-.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-HSJKAHyO.js

@@ -0,0 +1,346 @@
+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-FjsXmU7-.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