@danypops/pi-web-spider 0.10.4

package/test/fixtures/pi-loader-harness.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * pi-loader-harness.mjs — 1:1 reproduction of Pi's production extension loader.
+ *
+ * Uses Pi's ACTUAL loadExtensionModule() jiti setup (same import.meta.url anchor,
+ * same alias map, same tryNative default) by re-exporting the internal function
+ * via a thin shim. This is the only way to reproduce bugs that only surface in
+ * Pi's production load path (e.g. "Map operation called on non-Map object").
+ *
+ * Emits NDJSON on stdout — same format as mock-pi-cli.mjs and Pi's --mode json.
+ *
+ * Args:
+ *   --extension <path>   extension entry point
+ *   --tool <name>        tool to invoke (default: web_fetch)
+ *   --params <json>      tool params as JSON
+ *   --env KEY=VALUE      env overrides (repeatable)
+ */
+
+import { resolve } from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+// ---------------------------------------------------------------------------
+// Args
+// ---------------------------------------------------------------------------
+const args  = process.argv.slice(2)
+const get   = f => { const i = args.indexOf(f); return i !== -1 ? args[i+1] : null }
+const getAll = f => { const v = []; for (let i=0;i<args.length-1;i++) if(args[i]===f) v.push(args[i+1]); return v }
+
+const extensionPath = get("--extension")
+const toolName      = get("--tool") ?? "web_fetch"
+const paramsJson    = get("--params") ?? "{}"
+const envOverrides  = Object.fromEntries(getAll("--env").map(s => s.split("=", 2)))
+
+if (!extensionPath) { process.stderr.write("--extension required\n"); process.exit(1) }
+
+for (const [k,v] of Object.entries(envOverrides)) process.env[k] = v
+
+// ---------------------------------------------------------------------------
+// Load Pi's actual extension infrastructure
+// ---------------------------------------------------------------------------
+const PI_LOADER = "/home/dpopsuev/Workspace/pi-mono/packages/coding-agent/dist/core/extensions/loader.js"
+
+const {
+  createExtensionRuntime,
+  loadExtensions,
+} = await import(pathToFileURL(PI_LOADER).href)
+
+// ---------------------------------------------------------------------------
+// Minimal EventBus stub — only what loadExtensions needs
+// ---------------------------------------------------------------------------
+const eventBus = {
+  emit() {},
+  on()  {},
+  off() {},
+}
+
+// ---------------------------------------------------------------------------
+// Load extension through Pi's EXACT production path
+// ---------------------------------------------------------------------------
+const runtime   = createExtensionRuntime()
+const absExtPath = resolve(extensionPath)
+
+// loadExtensions returns { extensions, errors, runtime }
+const { extensions, errors } = await loadExtensions([absExtPath], process.cwd(), eventBus)
+
+if (errors.length) {
+  process.stderr.write(`[pi-loader-harness] load errors: ${JSON.stringify(errors)}\n`)
+  process.exit(1)
+}
+if (!extensions.length) {
+  process.stderr.write(`[pi-loader-harness] no extensions loaded\n`)
+  process.exit(1)
+}
+
+// ---------------------------------------------------------------------------
+// Find the registered tool
+// ---------------------------------------------------------------------------
+const toolEntry = extensions[0].tools.get(toolName)
+if (!toolEntry) {
+  process.stderr.write(`[pi-loader-harness] tool not found: ${toolName}\n`)
+  process.exit(1)
+}
+
+const params = JSON.parse(paramsJson)
+emit({ type: "tool_execution_start", toolName, args: params })
+
+try {
+  const result = await toolEntry.definition.execute(`harness-${Date.now()}`, params)
+  emit({ type: "tool_execution_end", toolName, result })
+  emit({ type: "exit", code: 0 })
+} catch (err) {
+  emit({ type: "tool_execution_error", toolName, error: err?.message ?? String(err) })
+  emit({ type: "exit", code: 1 })
+}
+
+function emit(obj) { process.stdout.write(JSON.stringify(obj) + "\n") }

package/test/format.test.ts

@@ -0,0 +1,373 @@
+/**
+ * Token-efficiency tests for the web_fetch output formatters.
+ *
+ * The fixture is deliberately noisy — it mirrors real-world pages that have:
+ *   - 30+ navigation links (site menus, footer, breadcrumbs)
+ *   - 3 meaningful body links (actual content references)
+ *   - Empty metadata (no author, no description, no tags, no publishedAt)
+ *   - Rich heading structure already present in the markdown body
+ *   - A non-trivial word count
+ *
+ * Each test asserts that the corresponding formatter:
+ *   1. Includes only the fields an agent can act on
+ *   2. Excludes fields that are redundant, derivable, or always empty
+ *   3. Separates body links from nav-chrome links
+ *   4. Produces output that is measurably smaller than a naive full dump
+ */
+
+import { describe, expect, it } from "vitest";
+import type { SpideredPage } from "@danypops/web-spider";
+import {
+	bodyLinks,
+	highlightHit,
+	leanOutput,
+	linksOutput,
+	markdownOutput,
+	navLinksCount,
+	omitEmpty,
+} from "../src/format.js";
+
+// ---------------------------------------------------------------------------
+// Fixture
+// ---------------------------------------------------------------------------
+
+/** Generate N nav links simulating a typical site header/footer. */
+function makeNavLinks(n: number): SpideredPage["links"] {
+	return Array.from({ length: n }, (_, i) => ({
+		href: `https://example.com/nav-${i}`,
+		text: `Nav Item ${i}`,
+		isExternal: false,
+		rel: "nav" as const,
+	}));
+}
+
+const NOISY_PAGE: SpideredPage = {
+	url: "https://example.com/how-ai-agents-work",
+	domain: "example.com",
+	fetchedAt: "2024-06-01T12:00:00Z",
+	title: "How AI Agents Work",
+
+	// Empty metadata — common on many pages
+	description: "",
+	author: "",
+	publishedAt: "",
+	lang: "en",
+	tags: [],
+
+	wordCount: 820,
+	readingTimeMinutes: 5, // wordCount / 200 — derivable, not actionable
+
+	headings: [
+		{ level: 1, text: "How AI Agents Work" },
+		{ level: 2, text: "What is an Agent?" },
+		{ level: 2, text: "Memory and State" },
+		{ level: 3, text: "Short-term Memory" },
+		{ level: 3, text: "Long-term Memory" },
+		{ level: 2, text: "Tool Use" },
+		{ level: 2, text: "Conclusion" },
+	],
+
+	chunks: [
+		{ id: "c0", index: 0, heading: "What is an Agent?", text: "An agent is a system that perceives its environment and takes actions.", wordCount: 13, contentType: "text" },
+		{ id: "c1", index: 1, heading: "Memory and State", text: "Memory allows agents to retain information across interactions.", wordCount: 10, contentType: "text" },
+	],
+
+	links: [
+		// 30 nav links — site header, footer, sidebar
+		...makeNavLinks(30),
+		// 3 body links — actual content references
+		{ href: "https://arxiv.org/abs/2309.00864", text: "ReAct paper", isExternal: true, rel: "body" },
+		{ href: "https://example.com/memory-in-llms", text: "Memory in LLMs", isExternal: false, rel: "body" },
+		{ href: "https://example.com/tool-use", text: "Tool Use survey", isExternal: false, rel: "body" },
+	],
+
+	// Headings are already present as ## lines inside the markdown body
+	markdown: [
+		"# How AI Agents Work",
+		"",
+		"## What is an Agent?",
+		"",
+		"An agent is a system that perceives its environment and takes actions.",
+		"See the [ReAct paper](https://arxiv.org/abs/2309.00864) for details.",
+		"",
+		"## Memory and State",
+		"",
+		"Memory allows agents to retain information across interactions.",
+		"Read more in [Memory in LLMs](https://example.com/memory-in-llms).",
+		"",
+		"### Short-term Memory",
+		"",
+		"Short-term memory is the working context of an agent.",
+		"",
+		"### Long-term Memory",
+		"",
+		"Long-term memory persists across sessions.",
+		"",
+		"## Tool Use",
+		"",
+		"Agents use tools to interact with the world. See the [Tool Use survey](https://example.com/tool-use).",
+		"",
+		"## Conclusion",
+		"",
+		"AI agents combine perception, memory, and action to solve complex tasks.",
+	].join("\n"),
+};
+
+// Baseline: what a naive full dump looks like
+const NAIVE_DUMP = JSON.stringify(NOISY_PAGE);
+
+// ---------------------------------------------------------------------------
+// omitEmpty
+// ---------------------------------------------------------------------------
+
+describe("omitEmpty", () => {
+	it("removes empty strings", () => {
+		const result = omitEmpty({ a: "hello", b: "", c: "world" });
+		expect(result).toEqual({ a: "hello", c: "world" });
+	});
+
+	it("removes empty arrays", () => {
+		const result = omitEmpty({ tags: [], links: ["a"] });
+		expect(result).toEqual({ links: ["a"] });
+	});
+
+	it("removes undefined", () => {
+		const result = omitEmpty({ a: 1, b: undefined });
+		expect(result).toEqual({ a: 1 });
+	});
+
+	it("removes false", () => {
+		const result = omitEmpty({ jsRendered: false, wordCount: 100 });
+		expect(result).toEqual({ wordCount: 100 });
+	});
+
+	it("keeps 0 — zero is a real value", () => {
+		const result = omitEmpty({ count: 0, name: "x" });
+		expect(result).toEqual({ count: 0, name: "x" });
+	});
+
+	it("keeps null — null is a real value", () => {
+		const result = omitEmpty({ val: null, name: "x" });
+		expect(result).toEqual({ val: null, name: "x" });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Link splitting
+// ---------------------------------------------------------------------------
+
+describe("bodyLinks / navLinksCount", () => {
+	it("extracts only body links", () => {
+		const bl = bodyLinks(NOISY_PAGE);
+		expect(bl).toHaveLength(3);
+		expect(bl.every((l) => !l.hasOwnProperty("rel"))).toBe(true);
+		expect(bl.map((l) => l.href)).toContain("https://arxiv.org/abs/2309.00864");
+	});
+
+	it("counts nav links correctly", () => {
+		expect(navLinksCount(NOISY_PAGE)).toBe(30);
+	});
+
+	it("body + nav accounts for all links", () => {
+		expect(bodyLinks(NOISY_PAGE).length + navLinksCount(NOISY_PAGE)).toBe(NOISY_PAGE.links.length);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// leanOutput
+// ---------------------------------------------------------------------------
+
+describe("leanOutput", () => {
+	const out = leanOutput(NOISY_PAGE);
+
+	it("includes essential identity fields", () => {
+		expect(out.url).toBe(NOISY_PAGE.url);
+		expect(out.title).toBe(NOISY_PAGE.title);
+		expect(out.wordCount).toBe(NOISY_PAGE.wordCount);
+	});
+
+	it("includes headings as flat markdown strings", () => {
+		expect(Array.isArray(out.headings)).toBe(true);
+		const headings = out.headings as string[];
+		expect(headings[0]).toBe("# How AI Agents Work");
+		expect(headings[1]).toBe("## What is an Agent?");
+		expect(headings[3]).toBe("### Short-term Memory");
+	});
+
+	it("includes only body links, not the nav flood", () => {
+		const bl = out.bodyLinks as Array<{ href: string; text: string }>;
+		expect(Array.isArray(bl)).toBe(true);
+		expect(bl).toHaveLength(3);
+	});
+
+	it("surfaces nav count instead of nav links", () => {
+		expect(out.navLinksCount).toBe(30);
+		expect(out).not.toHaveProperty("links");
+	});
+
+	it("omits empty metadata fields", () => {
+		expect(out).not.toHaveProperty("description");
+		expect(out).not.toHaveProperty("author");
+		expect(out).not.toHaveProperty("publishedAt");
+		expect(out).not.toHaveProperty("tags");
+	});
+
+	it("omits derivable and non-actionable fields", () => {
+		expect(out).not.toHaveProperty("domain");
+		expect(out).not.toHaveProperty("readingTimeMinutes");
+		expect(out).not.toHaveProperty("fetchedAt");
+		expect(out).not.toHaveProperty("lang");
+	});
+
+	it("omits prose body fields", () => {
+		expect(out).not.toHaveProperty("markdown");
+		expect(out).not.toHaveProperty("chunks");
+	});
+
+	it("omits jsRendered when false", () => {
+		expect(out).not.toHaveProperty("jsRendered");
+	});
+
+	it("includes jsRendered when true", () => {
+		const jsPage = { ...NOISY_PAGE, jsRendered: true };
+		const jsOut = leanOutput(jsPage);
+		expect(jsOut.jsRendered).toBe(true);
+	});
+
+	it("is materially smaller than a naive full dump", () => {
+		const leanSize = JSON.stringify(out).length;
+		// The naive dump includes 30 full link objects, all markdown, all chunks.
+		// Lean should be well under half.
+		expect(leanSize).toBeLessThan(NAIVE_DUMP.length * 0.5);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// markdownOutput
+// ---------------------------------------------------------------------------
+
+describe("markdownOutput", () => {
+	const out = markdownOutput(NOISY_PAGE);
+
+	it("includes essential fields for reading", () => {
+		expect(out.url).toBe(NOISY_PAGE.url);
+		expect(out.title).toBe(NOISY_PAGE.title);
+		expect(out.wordCount).toBe(NOISY_PAGE.wordCount);
+		expect(out.markdown).toBe(NOISY_PAGE.markdown);
+	});
+
+	it("omits headings — they are already in the markdown body", () => {
+		expect(out).not.toHaveProperty("headings");
+	});
+
+	it("omits domain — derivable from url", () => {
+		expect(out).not.toHaveProperty("domain");
+	});
+
+	it("omits readingTimeMinutes — not actionable", () => {
+		expect(out).not.toHaveProperty("readingTimeMinutes");
+	});
+
+	it("omits links — not needed when reading prose", () => {
+		expect(out).not.toHaveProperty("links");
+	});
+
+	it("omits internal fields", () => {
+		expect(out).not.toHaveProperty("chunks");
+		expect(out).not.toHaveProperty("fetchedAt");
+		expect(out).not.toHaveProperty("lang");
+	});
+
+	it("omits empty metadata fields", () => {
+		expect(out).not.toHaveProperty("description");
+		expect(out).not.toHaveProperty("author");
+		expect(out).not.toHaveProperty("publishedAt");
+		expect(out).not.toHaveProperty("tags");
+	});
+
+	it("includes non-empty metadata fields", () => {
+		const richPage = { ...NOISY_PAGE, author: "Jane Smith", description: "A guide to AI agents." };
+		const richOut = markdownOutput(richPage);
+		expect(richOut.author).toBe("Jane Smith");
+		expect(richOut.description).toBe("A guide to AI agents.");
+	});
+
+	it("is materially smaller than a naive full dump", () => {
+		const size = JSON.stringify(out).length;
+		// Markdown output has the body text but not chunks, links, or redundant metadata.
+		expect(size).toBeLessThan(NAIVE_DUMP.length * 0.8);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// linksOutput
+// ---------------------------------------------------------------------------
+
+describe("linksOutput", () => {
+	const out = linksOutput(NOISY_PAGE);
+
+	it("includes url and title", () => {
+		expect(out.url).toBe(NOISY_PAGE.url);
+		expect(out.title).toBe(NOISY_PAGE.title);
+	});
+
+	it("returns only body links", () => {
+		const bl = out.bodyLinks as Array<{ href: string; text: string }>;
+		expect(bl).toHaveLength(3);
+	});
+
+	it("surfaces nav count, not nav links", () => {
+		expect(out.navLinksCount).toBe(30);
+		expect(out).not.toHaveProperty("links");
+	});
+
+	it("omits navLinksCount when there are no nav links", () => {
+		const noNavPage = {
+			...NOISY_PAGE,
+			links: NOISY_PAGE.links.filter((l) => l.rel === "body"),
+		};
+		const out2 = linksOutput(noNavPage);
+		expect(out2).not.toHaveProperty("navLinksCount");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// highlightHit
+// ---------------------------------------------------------------------------
+
+describe("highlightHit", () => {
+	const hit = {
+		heading: "Memory and State",
+		score: 0.87,
+		snippet: "Memory allows agents to retain",
+		chunkId: "c1",
+	};
+
+	it("returns the full chunk text, not the snippet", () => {
+		const result = highlightHit(hit, NOISY_PAGE.chunks);
+		expect(result.text).toBe(NOISY_PAGE.chunks[1]!.text);
+		// snippet is a substring of text — including both would be redundant
+		expect(result).not.toHaveProperty("snippet");
+	});
+
+	it("falls back to snippet when chunkId is not found", () => {
+		const result = highlightHit({ ...hit, chunkId: "missing" }, NOISY_PAGE.chunks);
+		expect(result.text).toBe(hit.snippet);
+	});
+
+	it("falls back to snippet when chunkId is absent", () => {
+		const { chunkId: _, ...noId } = hit;
+		const result = highlightHit(noId as typeof hit, NOISY_PAGE.chunks);
+		expect(result.text).toBe(hit.snippet);
+	});
+
+	it("omits heading when empty", () => {
+		const result = highlightHit({ ...hit, heading: "" }, NOISY_PAGE.chunks);
+		expect(result).not.toHaveProperty("heading");
+	});
+
+	it("includes heading when present", () => {
+		const result = highlightHit(hit, NOISY_PAGE.chunks);
+		expect(result.heading).toBe("Memory and State");
+	});
+});

package/test/live-fetch.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Live fetch tests — exercise the full execute() path against the real network.
+ *
+ * Purpose: catch the "Map operation called on non-Map object" class of failure
+ * that only surfaces when the extension runs with native ESM (tryNative:true),
+ * as pi's Node.js runtime does. The existing paths.test.ts covers jiti
+ * tryNative:false with mocked fetch; this file covers the native ESM path with
+ * a real HTTP round-trip.
+ *
+ * Two loader modes are tested to mirror both production code paths:
+ *
+ *   native ESM (direct import)   — matches pi's Node.js dev runtime
+ *   jiti tryNative:false         — matches pi's Bun binary + loadExtensionViaJiti
+ *
+ * Tests are skipped when offline (no LIVE_FETCH env var required — they use
+ * a timeout guard instead of an env flag so CI without network just times out
+ * gracefully rather than failing loudly).
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest"
+import {
+  createExtensionHarness,
+  loadExtensionViaJiti,
+  type ExtensionHarness,
+} from "@earendil-works/pi-coding-agent/testing"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const EXTENSION_PATH = join(__dirname, "../src/index.ts")
+
+// ---------------------------------------------------------------------------
+// Shared assertion — both loader modes must produce the same shape
+// ---------------------------------------------------------------------------
+
+async function assertWikipediaFetch(h: ExtensionHarness) {
+  const result = await h.invokeTool("web_fetch", {
+    url: "https://en.wikipedia.org/wiki/Web_crawler",
+    format: "lean",
+  }) as { content: { text: string }[] }
+
+  expect(result).toHaveProperty("content")
+  const text = JSON.parse(result.content[0].text)
+
+  // Must not be an error
+  expect(text).not.toHaveProperty("error")
+
+  // Must have expected shape
+  expect(text).toHaveProperty("url", "https://en.wikipedia.org/wiki/Web_crawler")
+  expect(text).toHaveProperty("title")
+  expect(typeof text.title).toBe("string")
+  expect(text.title.length).toBeGreaterThan(0)
+  expect(text).toHaveProperty("wordCount")
+  expect(text.wordCount).toBeGreaterThan(100)
+  expect(text).toHaveProperty("headings")
+  expect(Array.isArray(text.headings)).toBe(true)
+}
+
+// ---------------------------------------------------------------------------
+// Mode A: native ESM — matches pi's Node.js dev runtime (tryNative:true)
+// ---------------------------------------------------------------------------
+
+describe("live fetch — native ESM (pi Node.js runtime path)", () => {
+  let h: ExtensionHarness
+
+  beforeAll(async () => {
+    // Direct import — no jiti. This is how pi loads extensions in Node.js dev
+    // mode: the factory is imported natively, then wrapped in createExtensionHarness.
+    const { default: factory } = await import("../src/index.js")
+    h = createExtensionHarness(factory, { cwd: "/tmp" })
+    await h.boot()
+  })
+
+  afterAll(async () => {
+    await h.shutdown()
+  })
+
+  it("fetches Wikipedia lean — no Map errors, correct shape", async () => {
+    await assertWikipediaFetch(h)
+  }, 20_000)
+
+  it("fetches markdown format without error", async () => {
+    const result = await h.invokeTool("web_fetch", {
+      url: "https://en.wikipedia.org/wiki/Web_crawler",
+      format: "markdown",
+    }) as { content: { text: string }[] }
+
+    const text = JSON.parse(result.content[0].text)
+    expect(text).not.toHaveProperty("error")
+    expect(text).toHaveProperty("markdown")
+    expect(typeof text.markdown).toBe("string")
+    expect(text.markdown.length).toBeGreaterThan(100)
+  }, 20_000)
+
+  it("no url — returns cache listing, not error", async () => {
+    const result = await h.invokeTool("web_fetch", {}) as { content: { text: string }[] }
+    const text = JSON.parse(result.content[0].text)
+    // After fetching Wikipedia above, the cache has at least 1 entry.
+    // Regardless: must return listing shape, not an error.
+    expect(text).not.toHaveProperty("error")
+    expect(text).toHaveProperty("total")
+    expect(typeof text.total).toBe("number")
+  }, 5_000)
+})
+
+// ---------------------------------------------------------------------------
+// Mode B: jiti tryNative:false — matches Bun binary + loadExtensionViaJiti
+// ---------------------------------------------------------------------------
+
+describe("live fetch — jiti tryNative:false (Bun binary path)", () => {
+  let h: ExtensionHarness
+
+  beforeAll(async () => {
+    const factory = await loadExtensionViaJiti(EXTENSION_PATH)
+    h = createExtensionHarness(factory, { cwd: "/tmp" })
+    await h.boot()
+  })
+
+  afterAll(async () => {
+    await h.shutdown()
+  })
+
+  it("fetches Wikipedia lean — no Map errors, correct shape", async () => {
+    await assertWikipediaFetch(h)
+  }, 20_000)
+})

package/test/load.test.ts

@@ -0,0 +1,75 @@
+/**
+ * Extension load tests — two jiti modes.
+ *
+ * tryNative:false — Bun binary path. Class constructors from re-exported ESM
+ *   packages silently become undefined here; the factory uses dynamic import()
+ *   to avoid this.
+ * tryNative:true  — Node ESM baseline.
+ */
+
+import { join, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { describe, expect, it } from "vitest"
+import {
+  createExtensionHarness,
+  loadExtensionViaJiti,
+} from "@earendil-works/pi-coding-agent/testing"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const EXTENSION_PATH = join(__dirname, "../src/index.ts")
+
+// ── tryNative:false — Bun binary simulation ───────────────────────────────────
+
+describe("extension load — tryNative:false (Bun binary simulation)", () => {
+  it("loads without throwing", async () => {
+    const factory = await loadExtensionViaJiti(EXTENSION_PATH)
+    expect(typeof factory).toBe("function")
+  })
+
+  it("registers web_fetch when factory is called", async () => {
+    const factory = await loadExtensionViaJiti(EXTENSION_PATH)
+    const h = createExtensionHarness(factory, { cwd: "/tmp" })
+    await h.boot()
+    expect(h.tools.has("web_fetch")).toBe(true)
+    await h.shutdown()
+  })
+
+  it("registers exactly one tool", async () => {
+    const factory = await loadExtensionViaJiti(EXTENSION_PATH)
+    const h = createExtensionHarness(factory, { cwd: "/tmp" })
+    await h.boot()
+    expect(h.tools.size).toBe(1)
+    expect(h.tools.has("web_fetch")).toBe(true)
+    await h.shutdown()
+  })
+})
+
+// ── tryNative:true — Node ESM baseline ───────────────────────────────────────
+
+describe("extension load — tryNative:true (Node ESM baseline)", () => {
+  it("registers web_fetch", async () => {
+    const { default: factory } = await import("../src/index.js")
+    const h = createExtensionHarness(factory, { cwd: "/tmp" })
+    await h.boot()
+    expect(h.tools.has("web_fetch")).toBe(true)
+    await h.shutdown()
+  })
+
+  it("execute() returns valid result on first call — no crash at the Map boundary", async () => {
+    // The Map realm bug only surfaces on the first execute() call, not at
+    // construction time. The e2e-jiti tests cover the production jiti context;
+    // this guards the simpler failure of execute() crashing at all.
+    const { default: factory } = await import("../src/index.js")
+    const h = createExtensionHarness(factory, { cwd: "/tmp" })
+    await h.boot()
+
+    const result = await h.invokeTool("web_fetch", {}) as { content: { text: string }[] }
+    expect(result).toHaveProperty("content")
+    const text = JSON.parse(result.content[0].text)
+    expect(text).not.toHaveProperty("error")
+    expect(text).toHaveProperty("total")
+    expect(typeof text.total).toBe("number")
+
+    await h.shutdown()
+  })
+})