@gavin-hu/my-pi-agent 0.16.0 → 0.17.0

package/extensions/file-browse/palette.ts

@@ -0,0 +1,224 @@
+/**
+ * The quick-open palette: a fuzzy path search over `/api/files`.
+ *
+ * It is a fragment of the same IIFE `client.ts` ships (`PALETTE_CLIENT_JS` is
+ * interpolated into `CLIENT_JS`). The page's keymap opens it through
+ * `window.bfPalette`, the same contract shape as `window.bfKeys`.
+ */
+
+export const PALETTE_CLIENT_JS = `	// Quick open: a fuzzy path palette backed by /api/files.
+	var quickOpenButton = document.getElementById("quick-open");
+	var paletteBackdrop = null;
+	var paletteInput = null;
+	var paletteList = null;
+	var paletteStatus = null;
+	var paletteResults = [];
+	var paletteActive = -1;
+	var paletteTimer = null;
+
+	function paletteOpen() {
+		return paletteBackdrop !== null && paletteBackdrop.hidden === false;
+	}
+
+	function encodeSegments(path) {
+		return path.split("/").map(encodeURIComponent).join("/");
+	}
+
+	function closestRole(node, role) {
+		while (node && node !== paletteList) {
+			if (node.getAttribute && node.getAttribute("role") === role) return node;
+			node = node.parentNode;
+		}
+		return null;
+	}
+
+	function buildPalette() {
+		if (paletteBackdrop) return;
+		paletteBackdrop = document.createElement("div");
+		paletteBackdrop.className = "bf-dialog";
+		paletteBackdrop.hidden = true;
+		var dialog = document.createElement("div");
+		dialog.className = "bf-dialog__panel";
+		dialog.setAttribute("role", "dialog");
+		dialog.setAttribute("aria-modal", "true");
+		dialog.setAttribute("aria-label", "Quick open a file");
+		paletteInput = document.createElement("input");
+		paletteInput.type = "text";
+		paletteInput.className = "bf-dialog__input";
+		paletteInput.id = "palette-input";
+		paletteInput.setAttribute("role", "combobox");
+		paletteInput.setAttribute("aria-expanded", "true");
+		paletteInput.setAttribute("aria-controls", "palette-list");
+		paletteInput.setAttribute("aria-autocomplete", "list");
+		paletteInput.setAttribute("autocomplete", "off");
+		paletteInput.setAttribute("placeholder", "Type a file path…");
+		paletteInput.setAttribute("aria-label", "Quick open a file");
+		paletteList = document.createElement("ul");
+		paletteList.className = "bf-dialog__list";
+		paletteList.id = "palette-list";
+		paletteList.setAttribute("role", "listbox");
+		paletteStatus = document.createElement("p");
+		paletteStatus.className = "bf-dialog__status";
+		paletteStatus.setAttribute("role", "status");
+		dialog.appendChild(paletteInput);
+		dialog.appendChild(paletteList);
+		dialog.appendChild(paletteStatus);
+		paletteBackdrop.appendChild(dialog);
+		document.body.appendChild(paletteBackdrop);
+
+		paletteBackdrop.addEventListener("mousedown", function (event) {
+			if (event.target === paletteBackdrop) closePalette();
+		});
+		paletteInput.addEventListener("input", function () {
+			if (paletteTimer) window.clearTimeout(paletteTimer);
+			paletteTimer = window.setTimeout(runSearch, 80);
+		});
+		paletteInput.addEventListener("keydown", function (event) {
+			if (event.key === "Tab") {
+				event.preventDefault();
+			} else if (event.key === "ArrowDown" || (event.ctrlKey && event.key === "n")) {
+				event.preventDefault();
+				moveActive(1);
+			} else if (event.key === "ArrowUp" || (event.ctrlKey && event.key === "p")) {
+				event.preventDefault();
+				moveActive(-1);
+			} else if (event.key === "Enter") {
+				event.preventDefault();
+				openActive();
+			} else if (event.key === "Escape") {
+				event.preventDefault();
+				closePalette();
+			}
+		});
+		paletteList.addEventListener("mousemove", function (event) {
+			var option = closestRole(event.target, "option");
+			if (option) setActive(Number(option.getAttribute("data-index")));
+		});
+		paletteList.addEventListener("click", function (event) {
+			var option = closestRole(event.target, "option");
+			if (option) {
+				setActive(Number(option.getAttribute("data-index")));
+				openActive();
+			}
+		});
+	}
+
+	function openPalette() {
+		buildPalette();
+		paletteBackdrop.hidden = false;
+		document.body.classList.add("palette-open");
+		paletteInput.value = "";
+		renderResults([], "Searching…");
+		paletteInput.focus();
+		runSearch();
+	}
+
+	function closePalette() {
+		if (!paletteBackdrop) return;
+		paletteBackdrop.hidden = true;
+		document.body.classList.remove("palette-open");
+		if (quickOpenButton) quickOpenButton.focus();
+	}
+
+	function runSearch() {
+		var query = paletteInput.value.trim();
+		fetch("/api/files?q=" + encodeURIComponent(query))
+			.then(function (response) {
+				if (!response.ok) throw new Error("search failed");
+				return response.json();
+			})
+			.then(function (data) {
+				if (paletteInput.value.trim() !== query) return;
+				if (query === "") {
+					renderResults([], data.total + " files indexed" + (data.truncated ? " (truncated)" : ""));
+				} else {
+					renderResults(data.results || [], null);
+				}
+			})
+			.catch(function () {
+				renderResults([], "Search failed");
+			});
+	}
+
+	function appendHighlighted(target, path, positions) {
+		var marks = {};
+		(positions || []).forEach(function (index) { marks[index] = true; });
+		var buffer = "";
+		var marked = false;
+		function flush() {
+			if (buffer === "") return;
+			if (marked) {
+				var mark = document.createElement("mark");
+				mark.textContent = buffer;
+				target.appendChild(mark);
+			} else {
+				target.appendChild(document.createTextNode(buffer));
+			}
+			buffer = "";
+		}
+		for (var i = 0; i < path.length; i++) {
+			var isMatch = marks[i] === true;
+			if (isMatch !== marked) { flush(); marked = isMatch; }
+			buffer += path.charAt(i);
+		}
+		flush();
+	}
+
+	function renderResults(results, hint) {
+		paletteResults = results;
+		paletteActive = results.length > 0 ? 0 : -1;
+		paletteList.textContent = "";
+		results.forEach(function (result, index) {
+			var option = document.createElement("li");
+			option.className = "bf-dialog__option";
+			option.id = "palette-option-" + index;
+			option.setAttribute("role", "option");
+			option.setAttribute("data-index", String(index));
+			appendHighlighted(option, result.path, result.positions);
+			paletteList.appendChild(option);
+		});
+		if (hint) paletteStatus.textContent = hint;
+		else if (results.length === 0) paletteStatus.textContent = "No matches";
+		else paletteStatus.textContent = results.length + (results.length === 1 ? " match" : " matches");
+		updateActive();
+	}
+
+	function updateActive() {
+		Array.prototype.forEach.call(paletteList.children, function (option, index) {
+			option.setAttribute("aria-selected", index === paletteActive ? "true" : "false");
+		});
+		var active = paletteList.children[paletteActive];
+		if (paletteActive >= 0 && active) {
+			paletteInput.setAttribute("aria-activedescendant", "palette-option-" + paletteActive);
+			if (active.scrollIntoView) active.scrollIntoView({ block: "nearest" });
+		} else {
+			paletteInput.removeAttribute("aria-activedescendant");
+		}
+	}
+
+	function setActive(index) {
+		if (index < 0 || index >= paletteResults.length) return;
+		paletteActive = index;
+		updateActive();
+	}
+
+	function moveActive(delta) {
+		if (paletteResults.length === 0) return;
+		var next = paletteActive + delta;
+		if (next < 0) next = paletteResults.length - 1;
+		if (next >= paletteResults.length) next = 0;
+		setActive(next);
+	}
+
+	function openActive() {
+		var result = paletteResults[paletteActive];
+		if (result) window.location.assign("/view/" + encodeSegments(result.path));
+	}
+	var quickOpenButton = document.getElementById("quick-open");
+	if (quickOpenButton) quickOpenButton.addEventListener("click", openPalette);
+
+	window.bfPalette = {
+		open: openPalette,
+		close: closePalette,
+		isOpen: paletteOpen
+	};`;

package/extensions/file-browse/router.ts

@@ -20,7 +20,7 @@ import {
 	scriptHeaders,
 	type ServeResponse,
 } from "../../lib/http/index.ts";
-import { THEME_JS } from "../../lib/web/index.ts";
+import { THEME_JS, THEME_JS_PATH } from "../../lib/web/index.ts";
 import { CLIENT_JS } from "./client.ts";
 import type { ServeConfig } from "./config.ts";
 import { isDiffMode, type DiffMode } from "./diff.ts";
@@ -352,7 +352,7 @@ export async function handleRequest(
 
 	try {
 		if (pathname === "/app.js") return { status: 200, headers: scriptHeaders(), body: CLIENT_JS };
-		if (pathname === "/theme.js") return { status: 200, headers: scriptHeaders(), body: THEME_JS };
+		if (pathname === THEME_JS_PATH) return { status: 200, headers: scriptHeaders(), body: THEME_JS };
 		if (pathname === "/favicon.ico") return { status: 204, headers: pageHeaders(), body: "" };
 		if (pathname === "/api/tree") return await treeApi(ctx, search.get("path") ?? "");
 		if (pathname === "/api/files") return await filesApi(ctx, search.get("q") ?? "");

package/extensions/file-browse/styles.ts

@@ -19,9 +19,6 @@ export const BROWSE_CSS = `${WEB_BASE_CSS}
 ${WEB_THEME_CSS}
 ${WEB_LAYOUT_CSS}
 ${WEB_COMPONENTS_CSS}
-${WEB_THEME_CSS}
-${WEB_LAYOUT_CSS}
-${WEB_COMPONENTS_CSS}
 .browse-side{padding:var(--space-3)}
 .browse-root{flex:1 1 auto;direction:rtl;text-align:left}
 .browse-git{font-family:var(--font-mono)}
@@ -121,4 +118,12 @@ body.palette-open{overflow:hidden}
 }
 @media (max-width:520px){
 .bf-toolbar .bf-theme-toggle{margin-left:auto}
+}
+/* A printed page scrolls nothing: the card and its body open up, the pinned hunk
+   header stops pinning, and the progress hairline belongs to the screen. */
+@media print{
+.bf-card{border:0}
+.bf-card,.bf-app__main,.bf-code,.bf-md,.bf-diff,.browse-listing{height:auto!important;max-height:none!important;overflow:visible!important}
+.bf-diff .bf-diff-line--hunk{position:static}
+.browse-progress{display:none}
 }`;

package/extensions/file-browse/tree.ts

@@ -0,0 +1,381 @@
+/**
+ * The browse page's sidebar: the path filter, the fold-all control, the lazy
+ * tree, and the tree's keyboard model.
+ *
+ * It is a fragment of the same IIFE `client.ts` ships (`TREE_CLIENT_JS` is
+ * interpolated into `CLIENT_JS`), kept in its own module because the sidebar is
+ * one concern with its own state: the filter query, each folder's `data-open`
+ * intent, and the one row the keyboard is on.
+ */
+
+import { SIDEBAR_COLLAPSE_MAX } from "../../lib/web/index.ts";
+
+export const TREE_CLIENT_JS = `	var tree = document.querySelector("nav.bf-tree");
+	var filter = document.getElementById("filter");
+	var foldAllButton = document.getElementById("fold-all");
+	var query = "";
+
+	function matches(text) {
+		return !query || text.toLowerCase().indexOf(query) !== -1;
+	}
+
+	// A row is found from inside it (an event target) or from its own list item:
+	// closest() only looks upwards, so paint() cannot start from the li.
+	function rowOf(node) {
+		var row = node && node.closest ? node.closest(".bf-tree__row") : null;
+		return row && tree && tree.contains(row) ? row : null;
+	}
+
+	function rowFor(li) {
+		return li ? li.querySelector(":scope > .bf-tree__row") : null;
+	}
+
+	function rowLink(row) {
+		return row ? row.querySelector("a") : null;
+	}
+
+	var SVG_NS = "http://www.w3.org/2000/svg";
+
+	function svgIcon(entry) {
+		var svg = document.createElementNS(SVG_NS, "svg");
+		svg.setAttribute("class", "browse-cat " + (entry.colorClass || ""));
+		svg.setAttribute("aria-hidden", "true");
+		svg.setAttribute("title", entry.label || "");
+		var use = document.createElementNS(SVG_NS, "use");
+		use.setAttribute("href", entry.iconHref);
+		svg.appendChild(use);
+		return svg;
+	}
+
+	function buildNode(entry) {
+		var li = document.createElement("li");
+		var row = document.createElement("div");
+		row.className = "bf-tree__row";
+		row.setAttribute("data-path", entry.path || "");
+		var twisty = document.createElement(entry.isDir ? "button" : "span");
+		twisty.className = "bf-tree__tw";
+		row.appendChild(twisty);
+		row.appendChild(svgIcon(entry));
+		if (entry.isDir) {
+			li.dataset.open = "false";
+			twisty.classList.add("bf-tree__tw--toggle");
+			twisty.type = "button";
+			twisty.tabIndex = -1;
+			twisty.setAttribute("aria-hidden", "true");
+			twisty.textContent = "\\u25B8";
+			var dir = document.createElement("a");
+			dir.href = entry.href;
+			dir.tabIndex = -1;
+			dir.setAttribute("aria-expanded", "false");
+			dir.textContent = entry.name + "/";
+			row.appendChild(dir);
+		} else if (entry.broken) {
+			twisty.className = "bf-tree__tw bf-tree__tw--spacer";
+			twisty.setAttribute("aria-hidden", "true");
+			var broken = document.createElement("span");
+			broken.className = "browse-broken";
+			broken.title = "broken symbolic link";
+			broken.textContent = entry.name;
+			row.appendChild(broken);
+			var mark = document.createElement("span");
+			mark.className = "browse-link-mark";
+			mark.textContent = "\\u21A9";
+			row.appendChild(mark);
+		} else {
+			twisty.className = "bf-tree__tw bf-tree__tw--spacer";
+			twisty.setAttribute("aria-hidden", "true");
+			var file = document.createElement("a");
+			file.href = entry.href;
+			file.tabIndex = -1;
+			file.textContent = entry.name;
+			row.appendChild(file);
+		}
+		li.appendChild(row);
+		return li;
+	}
+
+	function filterNode(li) {
+		var row = li.querySelector(":scope > .bf-tree__row");
+		var own = matches(row ? row.getAttribute("data-path") || row.textContent : "");
+		var childMatch = false;
+		Array.prototype.forEach.call(li.querySelectorAll(":scope > ul > li"), function (child) {
+			if (filterNode(child)) childMatch = true;
+		});
+		var visible = own || childMatch;
+		li.hidden = !visible;
+		return visible;
+	}
+
+	function applyFilter() {
+		var empty = document.getElementById("tree-empty");
+		var anyTree = false;
+		if (tree) {
+			Array.prototype.forEach.call(tree.querySelectorAll(":scope > ul > li"), function (li) {
+				if (filterNode(li)) anyTree = true;
+			});
+		}
+		if (empty) empty.hidden = !tree || anyTree;
+		Array.prototype.forEach.call(document.querySelectorAll("table.bf-table tbody tr"), function (row) {
+			var path = row.getAttribute("data-path") || row.getAttribute("data-name") || "";
+			row.hidden = !matches(path);
+		});
+		// Lists are repainted too: while a query is active every list is shown, and
+		// clearing the query brings the folds back.
+		if (tree) Array.prototype.forEach.call(tree.querySelectorAll("li[data-open]"), paint);
+	}
+
+	if (filter) {
+		filter.addEventListener("input", function () {
+			query = filter.value.trim().toLowerCase();
+			applyFilter();
+		});
+	}
+
+	// Visibility is derived: the intent in data-open, opened up while a filter is
+	// active so a fold cannot hide a match.
+	function isOpen(li) {
+		return query !== "" || li.dataset.open === "true";
+	}
+
+	function paint(li) {
+		var row = rowFor(li);
+		var twisty = row ? row.querySelector(":scope > .bf-tree__tw") : null;
+		if (!twisty || twisty.tagName !== "BUTTON") return;
+		var open = isOpen(li);
+		// A pending load owns the glyph until it lands or fails.
+		if (!li.dataset.loading && !li.dataset.error) twisty.textContent = open ? "\\u25BE" : "\\u25B8";
+		var link = rowLink(row);
+		if (link) link.setAttribute("aria-expanded", open ? "true" : "false");
+		var list = li.querySelector(":scope > ul");
+		if (list) list.hidden = !open;
+	}
+
+	function setOpen(li, open) {
+		li.dataset.open = open ? "true" : "false";
+		paint(li);
+	}
+
+	// Every dir with rendered children: what the fold-all control acts on.
+	function foldableDirs() {
+		var dirs = [];
+		if (!tree) return dirs;
+		Array.prototype.forEach.call(tree.querySelectorAll("li"), function (li) {
+			if (li.querySelector(":scope > ul")) dirs.push(li);
+		});
+		return dirs;
+	}
+
+	function syncFoldButton() {
+		if (!foldAllButton) return;
+		var dirs = foldableDirs();
+		var open = 0;
+		dirs.forEach(function (li) {
+			if (li.dataset.open === "true") open++;
+		});
+		foldAllButton.hidden = dirs.length === 0;
+		foldAllButton.textContent = open > 0 ? "fold all" : "expand all";
+	}
+
+	function setAll(open) {
+		foldableDirs().forEach(function (li) {
+			setOpen(li, open);
+		});
+		syncFoldButton();
+	}
+
+	function loadChildren(li, twisty, path) {
+		var link = rowLink(rowFor(li));
+		var name = link ? link.textContent.slice(0, -1) : path;
+		li.dataset.loading = "true";
+		twisty.textContent = "\\u2026";
+		if (link) link.setAttribute("aria-busy", "true");
+		fetch("/api/tree?path=" + encodeURIComponent(path))
+			.then(function (response) {
+				if (!response.ok) throw new Error("load failed");
+				return response.json();
+			})
+			.then(function (data) {
+				var built = document.createElement("ul");
+				(data.entries || []).forEach(function (entry) {
+					built.appendChild(buildNode(entry));
+				});
+				li.appendChild(built);
+				delete li.dataset.loading;
+				delete li.dataset.error;
+				setOpen(li, true);
+				if (link) link.setAttribute("aria-busy", "false");
+				applyFilter();
+			})
+			.catch(function () {
+				delete li.dataset.loading;
+				li.dataset.error = "true";
+				li.dataset.open = "false";
+				twisty.textContent = "\\u26A0";
+				twisty.title = "Could not load " + name + ". Press to retry.";
+				if (link) {
+					link.setAttribute("aria-busy", "false");
+					link.setAttribute("aria-expanded", "false");
+				}
+			});
+	}
+
+	if (tree) {
+		tree.addEventListener("click", function (event) {
+			var twisty = event.target.closest(".bf-tree__tw");
+			if (!twisty || twisty.tagName !== "BUTTON" || !tree.contains(twisty)) return;
+			event.preventDefault();
+			var li = twisty.closest("li");
+			if (!li) return;
+			var list = li.querySelector(":scope > ul");
+			if (li.dataset.open === "true") {
+				setOpen(li, false);
+				return;
+			}
+			if (list) {
+				setOpen(li, true);
+				applyFilter();
+				return;
+			}
+			var row = li.querySelector(":scope > .bf-tree__row");
+			var path = row ? row.getAttribute("data-path") : null;
+			if (!path) return;
+			loadChildren(li, twisty, path);
+		});
+	}
+
+	// The tree is one tab stop. Arrows move between the rows a reader can see,
+	// Right opens a folder (reading it first when it has never been loaded),
+	// Left closes it or steps out to the parent, Space toggles, and Enter follows
+	// the focused link itself — the row is a link, so the browser owns activation.
+	function treeRows() {
+		return tree ? Array.prototype.slice.call(tree.querySelectorAll(".bf-tree__row")) : [];
+	}
+
+	function visibleRows() {
+		return treeRows().filter(function (row) { return row.getClientRects().length > 0; });
+	}
+
+	function setTabStop(row) {
+		treeRows().forEach(function (other) {
+			var link = rowLink(other);
+			if (link) link.tabIndex = other === row ? 0 : -1;
+		});
+	}
+
+	function focusRow(row) {
+		if (!row) return;
+		setTabStop(row);
+		var link = rowLink(row);
+		if (link) link.focus();
+	}
+
+	function moveFocus(row, delta) {
+		var rows = visibleRows();
+		var at = rows.indexOf(row);
+		if (at >= 0) focusRow(rows[at + delta]);
+	}
+
+	function parentRowOf(row) {
+		var li = row.parentNode;
+		var list = li ? li.parentNode : null;
+		var parentLi = list && list.closest ? list.closest("li") : null;
+		return parentLi ? parentLi.querySelector(":scope > .bf-tree__row") : null;
+	}
+
+	// A folder that has never been expanded has no child list yet; opening it is
+	// the same request the twisty makes, so the keyboard reuses it.
+	function openFolder(row) {
+		var li = row.parentNode;
+		var twisty = row.querySelector(".bf-tree__tw--toggle");
+		if (!li || !twisty) return null;
+		var list = li.querySelector(":scope > ul");
+		if (list) return list;
+		var path = row.getAttribute("data-path");
+		if (path) loadChildren(li, twisty, path);
+		return null;
+	}
+
+	function expandRow(row) {
+		var li = row.parentNode;
+		if (!li || !row.querySelector(".bf-tree__tw--toggle")) return;
+		var list = openFolder(row);
+		if (!list) return;
+		if (!isOpen(li)) {
+			setOpen(li, true);
+			applyFilter();
+			return;
+		}
+		var rows = visibleRows();
+		var next = rows[rows.indexOf(row) + 1];
+		if (next && parentRowOf(next) === row) focusRow(next);
+	}
+
+	function collapseRow(row) {
+		var li = row.parentNode;
+		if (li && li.querySelector(":scope > ul") && isOpen(li)) {
+			setOpen(li, false);
+			applyFilter();
+			return;
+		}
+		focusRow(parentRowOf(row));
+	}
+
+	function toggleRow(row) {
+		var li = row.parentNode;
+		if (!li || !row.querySelector(".bf-tree__tw--toggle")) return;
+		if (!openFolder(row)) return;
+		setOpen(li, li.dataset.open !== "true");
+		applyFilter();
+	}
+
+	if (tree) {
+		tree.addEventListener("keydown", function (event) {
+			var row = rowOf(event.target);
+			if (!row || event.metaKey || event.ctrlKey || event.altKey) return;
+			var rows = visibleRows();
+			if (event.key === "ArrowDown") moveFocus(row, 1);
+			else if (event.key === "ArrowUp") moveFocus(row, -1);
+			else if (event.key === "Home") focusRow(rows[0]);
+			else if (event.key === "End") focusRow(rows[rows.length - 1]);
+			else if (event.key === "ArrowRight") expandRow(row);
+			else if (event.key === "ArrowLeft") collapseRow(row);
+			else if (event.key === " " && row.querySelector(".bf-tree__tw--toggle")) toggleRow(row);
+			else return;
+			// The page keymap treats a bare key as its own; the tree keeps its own.
+			event.preventDefault();
+			event.stopPropagation();
+		});
+		// A pointer click lands on one row, so that row becomes the tab stop the
+		// next Tab returns to.
+		tree.addEventListener("focusin", function (event) {
+			var row = rowOf(event.target);
+			if (row) setTabStop(row);
+		});
+	}
+
+	// The current page's row, else the first one, is the way into the tree.
+	setTabStop(tree && tree.querySelector(".bf-tree__row[aria-current]") || (tree ? treeRows()[0] : null));
+
+	var panel = document.querySelector("details.bf-app__sidebar");
+	if (panel && window.matchMedia) {
+		var mq = window.matchMedia("(max-width: ${SIDEBAR_COLLAPSE_MAX}px)");
+		var syncSide = function () { panel.open = !mq.matches; };
+		syncSide();
+		if (mq.addEventListener) mq.addEventListener("change", syncSide);
+		else if (mq.addListener) mq.addListener(syncSide);
+	}
+
+	if (foldAllButton) {
+		foldAllButton.addEventListener("click", function () {
+			// The control folds when anything is open, and expands when nothing is.
+			var open = false;
+			foldableDirs().forEach(function (li) {
+				if (li.dataset.open === "true") open = true;
+			});
+			setAll(!open);
+		});
+	}
+
+	// The control starts in the state the rendered tree implies.
+	syncFoldButton();
+`;

package/extensions/file-read/README.md

@@ -201,7 +201,10 @@ config defaults, and error listing all derive from it.
 2. Add `extensions/file-read/extract/<fmt>.ts` exporting a `FormatExtractor` that
    `await import(...)`s its library, reads the bytes with `readFormatBytes`, and
    normalizes the output. Keep the parsing in a pure, exported helper so it is
-   testable without a real file.
+   testable without a real file. **The import goes inside the function**, not at
+   module scope: `formats.ts` imports every extractor when the tool registers, so
+   a module-scope import loads that library on every start — `test/dependencies.test.ts`
+   fails on exactly that.
 3. Add a `ReadFormat` entry to `FORMATS` and widen the `id` union.
 4. Add the new extractor to `extract/extract.test.ts` with a real minimal
    fixture, and extend `tool.test.ts` for format selection and config.

package/extensions/file-read/extract/odt.ts

@@ -5,11 +5,11 @@
  * unzips it with `fflate`, parses the XML with `fast-xml-parser`, and walks the
  * body for text: paragraphs and headings become lines, table cells are
  * tab-separated, and `text:s` / `text:tab` / `text:line-break` become their
- * whitespace. The walk over the parsed tree is pure and tested directly.
+ * whitespace. Both libraries load on the first ODT read, never at registration,
+ * so a session that never opens one pays nothing for them; the walk over the
+ * parsed tree is pure and tested directly.
  */
 
-import { strFromU8, unzipSync } from "fflate";
-import { XMLParser } from "fast-xml-parser";
 import { normalizeBodyText, readFormatBytes, type FormatExtractor } from "./file.ts";
 
 /** Elements that end a line. */
@@ -68,12 +68,13 @@ function collect(nodes: unknown, out: string[], inText: boolean): void {
 }
 
 /**
- * Extract plain text from the body of an ODT `content.xml`. Pure.
+ * Extract plain text from the body of an ODT `content.xml`.
  *
  * Trailing tabs and spaces at line ends, runs of blank lines, and the final
  * newline are stripped so the tool's paging sees ordinary text.
  */
-export function odtXmlToText(xml: string): string {
+export async function odtXmlToText(xml: string): Promise<string> {
+	const { XMLParser } = await import("fast-xml-parser");
 	const parser = new XMLParser({
 		preserveOrder: true,
 		ignoreAttributes: false,
@@ -94,6 +95,7 @@ export function odtXmlToText(xml: string): string {
 
 /** Extract the body text from an ODT file. */
 export const extractOdtText: FormatExtractor = async (file) => {
+	const { strFromU8, unzipSync } = await import("fflate");
 	const archive = unzipSync(await readFormatBytes(file));
 	const content = archive["content.xml"];
 	if (!content) throw new Error("ODT archive has no content.xml.");