texlite 0.8.0 → 0.8.2

package/dist/server/lucideIcons.js

@@ -0,0 +1,46 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { icons } from "lucide-react";
+import { normalizeLucideIconName } from "./projectIcons.js";
+/** Convert public Lucide component exports, e.g. AlarmClockMinus, to slugs. */
+function lucideSlug(componentName) {
+    return componentName
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLocaleLowerCase();
+}
+// `icons` is Lucide's public all-icons export.  Do not rely on its generated
+// dynamic import table: that is an implementation detail and has differed
+// across package versions and module loaders.  This index stays server-only,
+// so supporting the complete installed icon set does not enlarge the browser
+// bundle.
+const installedIcons = icons;
+const iconComponents = new Map();
+for (const [componentName, component] of Object.entries(installedIcons)) {
+    const slug = lucideSlug(componentName);
+    if (!iconComponents.has(slug))
+        iconComponents.set(slug, component);
+}
+const renderedIcons = new Map();
+/** Resolve an official Lucide icon slug to an installed icon. */
+export function resolveLucideIconName(value) {
+    const name = normalizeLucideIconName(value);
+    return name && iconComponents.has(name) ? name : null;
+}
+/** Render a verified Lucide icon once for use as a small, cacheable SVG mask. */
+export async function lucideIconSvg(name) {
+    const Icon = iconComponents.get(name);
+    if (!Icon)
+        return null;
+    const cached = renderedIcons.get(name);
+    if (cached)
+        return cached;
+    const svg = renderToStaticMarkup(createElement(Icon, {
+        size: 24,
+        strokeWidth: 1.9,
+        color: "#000",
+        "aria-hidden": true
+    }));
+    renderedIcons.set(name, svg);
+    return svg;
+}

package/dist/server/projectIcons.js

@@ -0,0 +1,96 @@
+/**
+ * A curated project-icon vocabulary.
+ *
+ * The client renders these with the Lucide icons already used throughout the
+ * application. They are the fast, searchable defaults; the server separately
+ * validates advanced choices against the installed Lucide catalogue.
+ */
+export const projectIconNames = [
+    "file-text",
+    "book-open",
+    "notebook-pen",
+    "book-marked",
+    "scroll-text",
+    "library",
+    "graduation-cap",
+    "presentation",
+    "image",
+    "folder-kanban",
+    "microscope",
+    "flask-conical",
+    "test-tube-diagonal",
+    "atom",
+    "dna",
+    "telescope",
+    "earth",
+    "map",
+    "languages",
+    "university",
+    "code-2",
+    "file-code-2",
+    "database",
+    "server",
+    "network",
+    "circuit-board",
+    "brain",
+    "brain-circuit",
+    "bot",
+    "shield-check",
+    "workflow",
+    "sigma",
+    "calculator",
+    "chart-no-axes-combined",
+    "line-chart",
+    "bar-chart-3",
+    "pie-chart",
+    "chart-scatter",
+    "file-spreadsheet",
+    "file-chart-column-increasing",
+    "lightbulb",
+    "rocket",
+    "target",
+    "sparkles",
+    "file-pen-line",
+    "file-stack",
+    "folder",
+    "folder-open",
+    "folder-archive",
+    "archive",
+    "bookmark",
+    "newspaper",
+    "notepad-text",
+    "sticky-note",
+    "pen-tool",
+    "quote",
+    "list-tree",
+    "file-search",
+    "beaker",
+    "test-tubes",
+    "folder-git-2",
+    "git-branch",
+    "terminal",
+    "braces",
+    "regex",
+    "cpu",
+    "hard-drive",
+    "cloud",
+    "users-round",
+    "calendar-days"
+];
+const projectIconNameSet = new Set(projectIconNames);
+export function isProjectIconName(value) {
+    return typeof value === "string" && projectIconNameSet.has(value);
+}
+/**
+ * Normalize an official Lucide icon slug (`file-text`). The optional
+ * `lucide:` prefix makes values copied from Iconify equally convenient.
+ * Availability is intentionally checked by the server-only Lucide module.
+ */
+export function normalizeLucideIconName(value) {
+    if (typeof value !== "string")
+        return null;
+    const compact = value.trim().replace(/^lucide:/i, "");
+    if (!compact || compact.length > 96)
+        return null;
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(compact) ? compact : null;
+}

package/dist/server/routes/projectShared.js

@@ -96,6 +96,7 @@ export function projectJson(project, tags = [], commentsSummary) {
         mainFile: project.main_file,
         latexmkrc: project.latexmkrc,
         engine: project.engine,
+        icon: project.icon,
         permission: project.permission,
         tags,
         unresolvedCommentCount: commentsSummary?.unresolvedCount ?? 0,

package/dist/server/routes/projects.js

@@ -6,6 +6,7 @@ import { maxCollaborativeFileBytes } from "../collaboration.js";
 import { createProjectFiles, duplicateProjectFiles, outputRoot, removeProjectDirectory, resolveSourcePath, safeRelativePath, sourceRoot } from "../files.js";
 import { apiError, contentDisposition, httpError } from "../http.js";
 import { isMainDocumentCandidate } from "../latexRoot.js";
+import { lucideIconSvg, resolveLucideIconName } from "../lucideIcons.js";
 import { accessibleProject, canEdit } from "../projects.js";
 import { writeProjectArchive } from "../archive.js";
 import { extractProjectZip, ZipValidationError } from "../zip.js";
@@ -14,6 +15,25 @@ import { commentsSummaryForProject, commentsSummaryForProjects, dictionaryWord,
 /** Register project catalog, metadata, archive, dictionary, tag, export, and deletion routes. */
 export function registerProjectCatalogRoutes(app, context) {
     const { config, db, collaboration, projectMutations, latexCompletions, projectOutlines, harper, recordHistory } = context;
+    // Advanced project icons are served as cacheable SVG masks. The browser
+    // therefore does not have to bundle Lucide's entire icon catalogue merely
+    // because an owner selected an icon outside the curated picker.
+    app.get("/api/project-icons/:name", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { name } = request.params;
+        const iconName = resolveLucideIconName(name);
+        if (!iconName)
+            return apiError(reply, 404, "PROJECT_ICON_INVALID");
+        const svg = await lucideIconSvg(iconName);
+        if (!svg)
+            return apiError(reply, 404, "PROJECT_ICON_INVALID");
+        return reply
+            .header("Cache-Control", "private, max-age=604800")
+            .type("image/svg+xml; charset=utf-8")
+            .send(svg);
+    });
     app.get("/api/tags", async (request, reply) => {
         const user = requireUser(request, reply, db);
         if (!user)
@@ -21,20 +41,84 @@ export function registerProjectCatalogRoutes(app, context) {
         const tags = db.prepare("SELECT id, name, color FROM user_tags WHERE user_id = ? ORDER BY name COLLATE NOCASE").all(user.id);
         return { tags };
     });
+    /**
+     * Return the current user's tag catalog together with usage counts.  This is
+     * intentionally separate from /api/tags: the lightweight catalog is loaded
+     * with every project-list refresh, while counts are only needed by the tag
+     * management dialog.
+     */
+    app.get("/api/tags/management", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const rows = db.prepare(`SELECT tag.id, tag.name, tag.color, COUNT(link.project_id) AS project_count
+      FROM user_tags tag
+      LEFT JOIN user_project_tag_links link ON link.tag_id = tag.id
+      WHERE tag.user_id = ?
+      GROUP BY tag.id
+      ORDER BY tag.name COLLATE NOCASE`).all(user.id);
+        return {
+            tags: rows.map(({ id, name, color, project_count }) => ({
+                id,
+                name,
+                color,
+                projectCount: Number(project_count) || 0
+            }))
+        };
+    });
     app.post("/api/tags", async (request, reply) => {
         const user = requireUser(request, reply, db);
         if (!user)
             return;
-        const body = request.body;
+        const body = (request.body ?? {});
         const name = text(body.name, 32);
         const color = tagColors.includes(body.color)
             ? body.color : "gray";
         const tag = { id: randomUUID(), name, color };
         const createdAt = now();
+        if (db.prepare("SELECT 1 FROM user_tags WHERE user_id = ? AND name = ?").get(user.id, tag.name)) {
+            return apiError(reply, 409, "TAG_NAME_EXISTS");
+        }
         db.prepare("INSERT INTO user_tags (id, name, color, user_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)")
             .run(tag.id, tag.name, tag.color, user.id, createdAt, createdAt);
         return reply.code(201).send({ tag });
     });
+    app.patch("/api/tags/:tagId", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { tagId } = request.params;
+        const body = (request.body ?? {});
+        const name = text(body.name, 32);
+        const color = tagColors.includes(body.color)
+            ? body.color : "gray";
+        const existing = db.prepare("SELECT id FROM user_tags WHERE id = ? AND user_id = ?").get(tagId, user.id);
+        if (!existing)
+            return apiError(reply, 404, "TAG_NOT_FOUND");
+        if (db.prepare("SELECT 1 FROM user_tags WHERE user_id = ? AND name = ? AND id <> ?").get(user.id, name, tagId)) {
+            return apiError(reply, 409, "TAG_NAME_EXISTS");
+        }
+        db.prepare("UPDATE user_tags SET name = ?, color = ?, updated_at = ? WHERE id = ? AND user_id = ?")
+            .run(name, color, now(), tagId, user.id);
+        return { tag: { id: tagId, name, color } };
+    });
+    app.delete("/api/tags/:tagId", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { tagId } = request.params;
+        const tag = db.prepare(`SELECT tag.id, COUNT(link.project_id) AS project_count
+      FROM user_tags tag
+      LEFT JOIN user_project_tag_links link ON link.tag_id = tag.id
+      WHERE tag.id = ? AND tag.user_id = ?
+      GROUP BY tag.id`).get(tagId, user.id);
+        if (!tag)
+            return apiError(reply, 404, "TAG_NOT_FOUND");
+        // Foreign-key cascading removes only this user's project/tag links. The
+        // projects and their source files are deliberately left untouched.
+        db.prepare("DELETE FROM user_tags WHERE id = ? AND user_id = ?").run(tag.id, user.id);
+        return { deletedId: tag.id, projectCount: Number(tag.project_count) || 0 };
+    });
     app.get("/api/projects", async (request, reply) => {
         const user = requireUser(request, reply, db);
         if (!user)
@@ -103,7 +187,7 @@ export function registerProjectCatalogRoutes(app, context) {
         const body = request.body;
         const project = {
             id: randomUUID(), owner_id: user.id, last_modified_by: user.id, name: text(body?.name, 120),
-            main_file: "main.tex", latexmkrc: null, engine: config.defaultEngine, created_at: now(), updated_at: now()
+            main_file: "main.tex", latexmkrc: null, engine: config.defaultEngine, icon: null, created_at: now(), updated_at: now()
         };
         createProjectFiles(config, project.id);
         try {
@@ -135,7 +219,7 @@ export function registerProjectCatalogRoutes(app, context) {
         const fallbackName = path.basename(part.filename, path.extname(part.filename));
         const project = {
             id: randomUUID(), owner_id: user.id, last_modified_by: user.id, name: text(query.name || fallbackName, 120),
-            main_file: "", latexmkrc: null, engine: config.defaultEngine, created_at: now(), updated_at: now()
+            main_file: "", latexmkrc: null, engine: config.defaultEngine, icon: null, created_at: now(), updated_at: now()
         };
         fs.mkdirSync(sourceRoot(config, project.id), { recursive: true, mode: 0o700 });
         fs.mkdirSync(outputRoot(config, project.id), { recursive: true, mode: 0o700 });
@@ -173,7 +257,7 @@ export function registerProjectCatalogRoutes(app, context) {
         const requestedName = typeof body?.name === "string" && body.name.trim() ? body.name : `${source.name.slice(0, 115)} (1)`;
         const project = {
             id: randomUUID(), owner_id: user.id, last_modified_by: user.id, name: text(requestedName, 120),
-            main_file: source.main_file, latexmkrc: source.latexmkrc, engine: source.engine, created_at: now(), updated_at: now()
+            main_file: source.main_file, latexmkrc: source.latexmkrc, engine: source.engine, icon: source.icon, created_at: now(), updated_at: now()
         };
         try {
             // Duplicate the source tree only after flushing the live Yjs room and
@@ -187,9 +271,9 @@ export function registerProjectCatalogRoutes(app, context) {
                     }
                 }
             });
-            db.prepare(`INSERT INTO projects (id, owner_id, last_modified_by, name, main_file, latexmkrc, engine, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(project.id, project.owner_id, project.last_modified_by, project.name, project.main_file, project.latexmkrc, project.engine, project.created_at, project.updated_at);
+            db.prepare(`INSERT INTO projects (id, owner_id, last_modified_by, name, main_file, latexmkrc, engine, icon, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(project.id, project.owner_id, project.last_modified_by, project.name, project.main_file, project.latexmkrc, project.engine, project.icon, project.created_at, project.updated_at);
         }
         catch (error) {
             removeProjectDirectory(config, project.id);
@@ -213,6 +297,29 @@ export function registerProjectCatalogRoutes(app, context) {
             project: projectJson(project, tagsForProject(db, id, user.id), commentsSummaryForProject(db, id))
         };
     });
+    /** Project icons are shared metadata, so only the project owner can change them. */
+    app.patch("/api/projects/:id/icon", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project || project.permission !== "owner")
+            return apiError(reply, 403, "PROJECT_OWNER_ONLY");
+        const body = (request.body ?? {});
+        const icon = body.icon === null ? null : resolveLucideIconName(body.icon);
+        if (body.icon !== null && !icon) {
+            return apiError(reply, 400, "PROJECT_ICON_INVALID");
+        }
+        const changedAt = now();
+        const updated = db.prepare("UPDATE projects SET icon = ?, updated_at = ?, last_modified_by = ? WHERE id = ? AND owner_id = ?")
+            .run(icon, changedAt, user.id, id, user.id);
+        if (!updated.changes)
+            return apiError(reply, 403, "PROJECT_OWNER_ONLY");
+        return {
+            project: projectJson(accessibleProject(db, id, user), tagsForProject(db, id, user.id), commentsSummaryForProject(db, id))
+        };
+    });
     app.put("/api/projects/:id/archive", async (request, reply) => {
         const user = requireUser(request, reply, db);
         if (!user)

package/dist/server/routes/wordCount.js

@@ -0,0 +1,83 @@
+import { requireUser } from "../auth.js";
+import { maxCollaborativeFileBytes } from "../collaboration.js";
+import { compileMainFile } from "../compileArtifacts.js";
+import { assertNoSourceSymlinks, safeRelativePath, sourceRoot } from "../files.js";
+import { apiError, httpError } from "../http.js";
+import { accessibleProject } from "../projects.js";
+import { TexcountExecutionError, TexcountUnavailableError } from "../texcount.js";
+/** Register host TeXcount-backed full-document and editor-selection counts. */
+export function registerWordCountRoutes(app, context) {
+    const { config, db, projectMutations, texcount } = context;
+    app.post("/api/projects/:id/word-count", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project)
+            return apiError(reply, 404, "PROJECT_NOT_FOUND");
+        const body = (request.body ?? {});
+        const mode = body.mode;
+        if (mode !== "full" && mode !== "selection")
+            return apiError(reply, 400, "WORD_COUNT_SOURCE_INVALID");
+        try {
+            if (mode === "selection") {
+                return await countSelection(config, id, body, texcount);
+            }
+            return await countDocument(config, db, projectMutations, texcount, id, user, body.mainFile);
+        }
+        catch (error) {
+            if (error instanceof TexcountUnavailableError)
+                return apiError(reply, 503, "WORD_COUNT_UNAVAILABLE");
+            if (error instanceof TexcountExecutionError)
+                return apiError(reply, 422, "WORD_COUNT_FAILED");
+            throw error;
+        }
+    });
+}
+async function countSelection(config, projectId, body, texcount) {
+    if (typeof body.path !== "string" || typeof body.source !== "string") {
+        throw httpError(400, "WORD_COUNT_SOURCE_INVALID");
+    }
+    let filePath;
+    try {
+        filePath = safeRelativePath(body.path);
+    }
+    catch {
+        throw httpError(400, "WORD_COUNT_SOURCE_INVALID");
+    }
+    // TeXcount's stdin parser is intended for TeX-like source. Keep BibTeX and
+    // binary resources out of this endpoint while allowing .sty/.cls snippets.
+    if (!/\.(?:tex|sty|cls)$/i.test(filePath) || !body.source.trim()) {
+        throw httpError(400, "WORD_COUNT_SOURCE_INVALID");
+    }
+    if (Buffer.byteLength(body.source, "utf8") > maxCollaborativeFileBytes(config)) {
+        throw httpError(413, "WORD_COUNT_SOURCE_TOO_LARGE");
+    }
+    const counts = await texcount.countSource(sourceRoot(config, projectId), body.source);
+    return { mode: "selection", path: filePath, ...counts };
+}
+async function countDocument(config, db, projectMutations, texcount, projectId, user, requestedMainFile) {
+    const initialProject = accessibleProject(db, projectId, user);
+    if (!initialProject)
+        throw httpError(404, "PROJECT_NOT_FOUND");
+    const mainFile = compileMainFile(config, projectId, initialProject.main_file, requestedMainFile);
+    if (!mainFile)
+        throw httpError(400, "MAIN_DOCUMENT_INVALID");
+    return await projectMutations.runConsistentRead(projectId, async () => {
+        // TeXcount follows \input/\include paths. Reject links before handing it
+        // the source root so a checked-out link cannot expose files outside it.
+        assertNoSourceSymlinks(config, projectId);
+        const counts = await texcount.countFile(sourceRoot(config, projectId), mainFile);
+        return { mode: "full", path: mainFile, ...counts };
+    }, {
+        preflight: () => {
+            const current = accessibleProject(db, projectId, user);
+            if (!current)
+                throw httpError(404, "PROJECT_NOT_FOUND");
+            const selected = compileMainFile(config, projectId, current.main_file, requestedMainFile);
+            if (!selected || selected !== mainFile)
+                throw httpError(400, "MAIN_DOCUMENT_INVALID");
+        }
+    });
+}

package/dist/server/texcount.js

@@ -0,0 +1,244 @@
+import { spawn } from "node:child_process";
+import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
+/** TeXcount is an optional host command supplied by TeX Live. */
+export const TEXCOUNT_COMMAND = "texcount";
+const TEXLITE_WORD_REPORT_PREFIX = "__TEXLITE_TEXCOUNT_WORDS__";
+const TEXLITE_CHARACTER_REPORT_PREFIX = "__TEXLITE_TEXCOUNT_CHARS__";
+// TeXcount placeholders {1} through {7} are, respectively: words in text,
+// header words, caption words, header count, float count, inline math, and
+// displayed math.  Do not parse TeXcount's human-facing prose report.
+const TEXLITE_WORD_REPORT_TEMPLATE = `${TEXLITE_WORD_REPORT_PREFIX}|{1}|{2}|{3}|{4}|{5}|{6}|{7}`;
+const TEXLITE_CHARACTER_REPORT_TEMPLATE = `${TEXLITE_CHARACTER_REPORT_PREFIX}|{1}|{2}|{3}|{4}|{5}|{6}|{7}`;
+const PROBE_TIMEOUT_MS = 5_000;
+const COUNT_TIMEOUT_MS = 30_000;
+const UNAVAILABLE_RETRY_MS = 15_000;
+const MAX_OUTPUT_BYTES = 512 * 1024;
+export class TexcountUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TexcountUnavailableError";
+    }
+}
+export class TexcountExecutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TexcountExecutionError";
+    }
+}
+/**
+ * Run the optional host TeXcount binary and normalize its explicit report
+ * template into stable fields for the browser. The command is intentionally
+ * fixed (rather than shell-evaluated) so project sources cannot inject flags.
+ */
+export class TexcountService {
+    command;
+    availability = "unknown";
+    lastUnavailableAt = 0;
+    probePromise = null;
+    activeChildren = new Set();
+    disposed = false;
+    constructor(command = TEXCOUNT_COMMAND) {
+        this.command = command;
+    }
+    async countFile(cwd, filePath) {
+        await this.ensureAvailable();
+        return this.count(cwd, ["-inc", "-total"], filePath);
+    }
+    async countSource(cwd, source) {
+        await this.ensureAvailable();
+        // A dash tells TeXcount to read one virtual TeX document from stdin. No
+        // include traversal is requested for a selection because the selection
+        // is not a complete project tree.
+        return this.count(cwd, ["-total"], "-", source);
+    }
+    async dispose() {
+        this.disposed = true;
+        for (const child of this.activeChildren)
+            killProcessGroup(child, "SIGTERM");
+        this.activeChildren.clear();
+        await this.probePromise?.catch(() => undefined);
+        this.probePromise = null;
+    }
+    async ensureAvailable() {
+        if (this.disposed)
+            throw new TexcountUnavailableError("TeXcount service stopped.");
+        if (this.availability === "available")
+            return;
+        if (this.availability === "unavailable" && Date.now() - this.lastUnavailableAt < UNAVAILABLE_RETRY_MS) {
+            throw new TexcountUnavailableError(`The optional ${this.command} command is not available.`);
+        }
+        if (this.probePromise)
+            return this.probePromise;
+        this.probePromise = this.runCommand(["--version"], undefined, undefined, PROBE_TIMEOUT_MS, 64 * 1024)
+            .then(({ code, stdout, stderr }) => {
+            if (code !== 0)
+                throw new Error((stderr || stdout).trim() || `exited with code ${code}`);
+            this.availability = "available";
+        })
+            .catch((error) => {
+            this.availability = "unavailable";
+            this.lastUnavailableAt = Date.now();
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new TexcountUnavailableError(`The optional ${this.command} command is unavailable: ${detail}`);
+        })
+            .finally(() => { this.probePromise = null; });
+        return this.probePromise;
+    }
+    async count(cwd, options, target, input) {
+        const [wordResult, characterResult] = await Promise.all([
+            this.runCommand([...options, `-template=${TEXLITE_WORD_REPORT_TEMPLATE}`, target], cwd, input),
+            this.runCommand([...options, "-char", `-template=${TEXLITE_CHARACTER_REPORT_TEMPLATE}`, target], cwd, input)
+        ]);
+        const words = this.finishWordCount(wordResult);
+        const characters = this.finishCharacterCount(characterResult);
+        return {
+            ...words,
+            totalCharacters: characters.text + characters.headers + characters.captions,
+            // TeXcount parses the same source twice. Do not show each syntax issue
+            // twice merely because character counting was requested as well.
+            parserErrors: Math.max(words.parserErrors, characters.parserErrors)
+        };
+    }
+    finishWordCount(result) {
+        if (result.code !== 0) {
+            throw new TexcountExecutionError(result.stderr.trim() || `${this.command} exited with code ${result.code}`);
+        }
+        try {
+            return parseTexcountOutput(result.stdout);
+        }
+        catch (error) {
+            throw new TexcountExecutionError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    finishCharacterCount(result) {
+        if (result.code !== 0) {
+            throw new TexcountExecutionError(result.stderr.trim() || `${this.command} exited with code ${result.code}`);
+        }
+        try {
+            return parseTexcountReport(result.stdout, TEXLITE_CHARACTER_REPORT_PREFIX);
+        }
+        catch (error) {
+            throw new TexcountExecutionError(error instanceof Error ? error.message : String(error));
+        }
+    }
+    runCommand(args, cwd, input, timeoutMs = COUNT_TIMEOUT_MS, outputLimit = MAX_OUTPUT_BYTES) {
+        return new Promise((resolve, reject) => {
+            if (this.disposed) {
+                reject(new TexcountUnavailableError("TeXcount service stopped."));
+                return;
+            }
+            let child;
+            try {
+                child = spawn(this.command, args, {
+                    cwd,
+                    env: { ...process.env, LC_ALL: "C" },
+                    shell: false,
+                    detached: detachedProcessGroup(),
+                    stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+                });
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            this.activeChildren.add(child);
+            const stdout = [];
+            const stderr = [];
+            let outputBytes = 0;
+            let settled = false;
+            let timedOut = false;
+            let outputTooLarge = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                killProcessGroup(child);
+            }, timeoutMs);
+            const finish = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.activeChildren.delete(child);
+                callback();
+            };
+            const terminateWithError = (error) => {
+                killProcessGroup(child);
+                finish(() => reject(error));
+            };
+            const collect = (target) => (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > outputLimit) {
+                    outputTooLarge = true;
+                    terminateWithError(new TexcountExecutionError(`${this.command} produced too much output.`));
+                    return;
+                }
+                target.push(chunk);
+            };
+            child.stdout?.on("data", collect(stdout));
+            child.stderr?.on("data", collect(stderr));
+            child.stdin?.on("error", (error) => terminateWithError(error));
+            child.once("error", (error) => finish(() => {
+                if (timedOut) {
+                    reject(new TexcountExecutionError(`${this.command} timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
+                    return;
+                }
+                if (error.code === "ENOENT") {
+                    reject(new TexcountUnavailableError(`The optional ${this.command} command is not available.`));
+                    return;
+                }
+                reject(error);
+            }));
+            child.once("close", (code) => finish(() => {
+                if (timedOut) {
+                    reject(new TexcountExecutionError(`${this.command} timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
+                    return;
+                }
+                if (outputTooLarge) {
+                    reject(new TexcountExecutionError(`${this.command} produced too much output.`));
+                    return;
+                }
+                resolve({
+                    code,
+                    stdout: Buffer.concat(stdout).toString("utf8"),
+                    stderr: Buffer.concat(stderr).toString("utf8")
+                });
+            }));
+            if (input !== undefined)
+                child.stdin?.end(input, "utf8");
+        });
+    }
+}
+/** Parse TexLite's explicit TeXcount template, rather than prose output. */
+export function parseTexcountOutput(output) {
+    const report = parseTexcountReport(output, TEXLITE_WORD_REPORT_PREFIX);
+    const filesMatch = /Files:\s*(\d+)/i.exec(output);
+    return {
+        textWords: report.text,
+        headerWords: report.headers,
+        captionWords: report.captions,
+        totalWords: report.text + report.headers + report.captions,
+        headers: report.headerCount,
+        floats: report.floatCount,
+        inlineMath: report.inlineMathCount,
+        displayMath: report.displayMathCount,
+        files: filesMatch ? Number(filesMatch[1]) : null,
+        parserErrors: report.parserErrors
+    };
+}
+function parseTexcountReport(output, prefix) {
+    const report = new RegExp(`${prefix}\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)`).exec(output);
+    if (!report) {
+        throw new Error("TeXcount did not return TexLite's expected report; a %TC:newtemplate or %TC:template directive may have overridden it.");
+    }
+    const [, text, header, caption, headerCount, floatCount, inlineMathCount, displayMathCount] = report;
+    const errorsMatch = /\(errors:\s*(\d+)\)/i.exec(output);
+    return {
+        text: Number(text),
+        headers: Number(header),
+        captions: Number(caption),
+        headerCount: Number(headerCount),
+        floatCount: Number(floatCount),
+        inlineMathCount: Number(inlineMathCount),
+        displayMathCount: Number(displayMathCount),
+        parserErrors: errorsMatch ? Number(errorsMatch[1]) : 0
+    };
+}