texlite 0.8.0 → 0.8.1

package/dist/server/environment.js

@@ -1,50 +1,167 @@
 import { spawn } from "node:child_process";
+import { LATEX_ENGINES } from "./config.js";
 import { httpError } from "./http.js";
 import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
-export async function assertEnvironment(config) {
-    const commands = [
-        { name: "latexmk", command: config.latexmk },
-        ...config.allowedEngines.map((command) => ({ name: command, command }))
-    ];
-    const checked = [];
-    const seen = new Set();
-    for (const item of commands) {
-        if (seen.has(item.command))
+export const MIN_NODE_MAJOR = 24;
+const commandProbeTimeoutMs = 10_000;
+const maxCommandOutputBytes = 64 * 1024;
+/**
+ * Probe all tools that are relevant to a TexLite host. Optional tools are
+ * included deliberately: their absence must be visible in `doctor`, but does
+ * not prevent TexLite from starting.
+ */
+export async function inspectHostEnvironment(config) {
+    return Promise.all(hostToolDefinitions(config).map((tool) => inspectTool(tool)));
+}
+/**
+ * Probe the default commands on PATH without loading a TexLite configuration.
+ * This supports pre-installation checks through `texlite requirements`.
+ */
+export async function inspectHostRequirements() {
+    return Promise.all(hostRequirementToolDefinitions().map((tool) => inspectTool(tool)));
+}
+export function hostRequirementsSatisfied(tools) {
+    if (tools.some((tool) => tool.requirement === "required" && tool.status !== "installed"))
+        return false;
+    const oneOfGroups = new Map();
+    for (const tool of tools) {
+        if (tool.requirement !== "one-of")
             continue;
-        seen.add(item.command);
-        const result = await commandVersion(item.command, 10_000);
-        if (result.error || result.status !== 0) {
-            const detail = result.error || result.stderr.trim() || `exit ${result.status ?? "unknown"}`;
-            throw new Error(`Environment check failed: could not run the ${item.name} command "${item.command}" (${detail}). Initialization/startup has been stopped.`);
-        }
-        const version = `${result.stdout || result.stderr}`.trim().split("\n")[0]?.slice(0, 160) || "available";
-        checked.push({ ...item, version });
+        const group = tool.requirementGroup ?? tool.id;
+        const members = oneOfGroups.get(group) ?? [];
+        members.push(tool);
+        oneOfGroups.set(group, members);
+    }
+    return [...oneOfGroups.values()].every((members) => members.some((tool) => tool.status === "installed"));
+}
+export async function assertEnvironment(config) {
+    const tools = await Promise.all(requiredToolDefinitions(config).map((tool) => inspectTool(tool)));
+    const unavailable = tools.find((tool) => tool.status !== "installed");
+    if (unavailable) {
+        const detail = unavailable.detail ?? "unknown error";
+        throw new Error(`Environment check failed: could not run the ${unavailable.name} command "${unavailable.command}" (${detail}). Initialization/startup has been stopped.`);
     }
-    return checked;
+    return tools.map(({ name, command, version }) => ({ name, command, version: version ?? "available" }));
 }
 export async function assertGitAvailable(config) {
-    const item = { name: "Git", command: config.git };
-    const result = await commandVersion(item.command, Math.min(config.gitOperationTimeoutMs, 10_000));
-    if (result.error || result.status !== 0) {
-        const detail = result.error || result.stderr.trim() || `exit ${result.status ?? "unknown"}`;
-        // Command output can reveal host paths; it remains a startup diagnostic,
-        // while API clients receive the localized, stable error code.
-        void detail;
+    const tool = await inspectTool(gitToolDefinition(config.git, Math.min(config.gitOperationTimeoutMs, commandProbeTimeoutMs)));
+    if (tool.status !== "installed")
         throw httpError(503, "GIT_UNAVAILABLE");
+    return { name: tool.name, command: tool.command, version: tool.version ?? "available" };
+}
+function requiredToolDefinitions(config) {
+    return [
+        { id: "node", name: `Node.js ${MIN_NODE_MAJOR}+`, command: "node", requirement: "required", purpose: "TexLite runtime" },
+        { id: "latexmk", name: "latexmk", command: config.latexmk, requirement: "required", purpose: "LaTeX compilation" },
+        ...config.allowedEngines.map((command) => ({
+            id: `engine:${command}`, name: command, command, requirement: "required",
+            purpose: "Configured LaTeX engine"
+        }))
+    ];
+}
+function hostToolDefinitions(config) {
+    return [
+        ...requiredToolDefinitions(config),
+        ...optionalToolDefinitions(config.git, Math.min(config.gitOperationTimeoutMs, commandProbeTimeoutMs))
+    ];
+}
+function hostRequirementToolDefinitions() {
+    return [
+        { id: "node", name: `Node.js ${MIN_NODE_MAJOR}+`, command: "node", requirement: "required", purpose: "TexLite runtime" },
+        { id: "latexmk", name: "latexmk", command: "latexmk", requirement: "required", purpose: "LaTeX compilation" },
+        ...LATEX_ENGINES.map((command) => ({
+            id: `engine:${command}`, name: command, command, requirement: "one-of",
+            requirementGroup: "latex-engine", purpose: "Supported LaTeX engine"
+        })),
+        ...optionalToolDefinitions("git", commandProbeTimeoutMs)
+    ];
+}
+function optionalToolDefinitions(gitCommand, gitTimeoutMs) {
+    return [
+        gitToolDefinition(gitCommand, gitTimeoutMs),
+        { id: "texcount", name: "TeXcount", command: "texcount", requirement: "optional", purpose: "Word and character statistics", versionArgs: ["-version"] },
+        { id: "bibtex", name: "BibTeX", command: "bibtex", requirement: "optional", purpose: "BibTeX bibliography builds" },
+        { id: "biber", name: "Biber", command: "biber", requirement: "optional", purpose: "Biber bibliography builds" },
+        { id: "makeindex", name: "MakeIndex", command: "makeindex", requirement: "optional", purpose: "Index generation", versionArgs: [] },
+        { id: "harper-cli", name: "Harper CLI", command: "harper-cli", requirement: "optional", purpose: "TexLite spelling and grammar checks" },
+        { id: "harper-ls", name: "Harper language server", command: "harper-ls", requirement: "optional", purpose: "External editor integration (not used by TexLite)" }
+    ];
+}
+function gitToolDefinition(command, timeoutMs) {
+    return { id: "git", name: "Git", command, requirement: "optional", purpose: "Git and GitHub backup", timeoutMs };
+}
+async function inspectTool(tool) {
+    if (tool.id === "node")
+        return inspectNode(tool);
+    const identity = toolIdentity(tool);
+    const result = await commandVersion(tool.command, tool.timeoutMs ?? commandProbeTimeoutMs, tool.versionArgs ?? ["--version"]);
+    if (!result.error && result.status === 0) {
+        return { ...identity, status: "installed", version: versionFromResult(result), detail: null };
     }
-    const version = `${result.stdout || result.stderr}`.trim().split("\n")[0]?.slice(0, 160) || "available";
-    return { ...item, version };
+    const missing = result.errorCode === "ENOENT";
+    return {
+        ...identity,
+        status: missing ? "missing" : "failed",
+        version: null,
+        detail: commandFailureDetail(result)
+    };
+}
+function inspectNode(tool) {
+    const identity = toolIdentity(tool);
+    const match = /^v(\d+)/.exec(process.version);
+    const major = match ? Number(match[1]) : Number.NaN;
+    if (Number.isInteger(major) && major >= MIN_NODE_MAJOR) {
+        return { ...identity, status: "installed", version: process.version, detail: null };
+    }
+    return {
+        ...identity,
+        status: "failed",
+        version: process.version || null,
+        detail: `TexLite requires Node.js ${MIN_NODE_MAJOR} or newer.`
+    };
+}
+function toolIdentity(tool) {
+    return {
+        id: tool.id,
+        name: tool.name,
+        command: tool.command,
+        requirement: tool.requirement,
+        requirementGroup: tool.requirementGroup,
+        purpose: tool.purpose
+    };
+}
+function versionFromResult(result) {
+    const lines = `${result.stdout}\n${result.stderr}`.split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !/^warning\b/i.test(line) && !/^possible precedence problem\b/i.test(line));
+    const versionLine = lines.find((line) => /\bversion\b|\bv?\d+\.\d+/i.test(line)) ?? lines[0];
+    return (versionLine ?? "available").slice(0, 160);
 }
-function commandVersion(command, timeoutMs) {
+function commandFailureDetail(result) {
+    const detail = result.error || result.stderr.trim() || result.stdout.trim() || `exit ${result.status ?? "unknown"}`;
+    return detail.replace(/\s+/g, " ").slice(0, 240);
+}
+function commandVersion(command, timeoutMs, args) {
     return new Promise((resolve) => {
-        const child = spawn(command, ["--version"], {
-            env: { ...process.env, LC_ALL: "C" }, shell: false, detached: detachedProcessGroup(),
-            stdio: ["ignore", "pipe", "pipe"]
-        });
+        let child;
+        try {
+            child = spawn(command, args, {
+                env: { ...process.env, LC_ALL: "C" }, shell: false, detached: detachedProcessGroup(),
+                stdio: ["ignore", "pipe", "pipe"]
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const errorCode = error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : null;
+            resolve({ status: null, stdout: "", stderr: "", error: message, errorCode });
+            return;
+        }
         const stdout = [];
         const stderr = [];
+        let outputBytes = 0;
         let settled = false;
         let timedOut = false;
+        let outputExceeded = false;
         const finish = (result) => {
             if (settled)
                 return;
@@ -53,11 +170,24 @@ function commandVersion(command, timeoutMs) {
             resolve({ ...result, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
         };
         const timer = setTimeout(() => { timedOut = true; killProcessGroup(child); }, timeoutMs);
-        child.stdout.on("data", (chunk) => { if (Buffer.concat(stdout).length < 64 * 1024)
-            stdout.push(chunk); });
-        child.stderr.on("data", (chunk) => { if (Buffer.concat(stderr).length < 64 * 1024)
-            stderr.push(chunk); });
-        child.once("error", (error) => finish({ status: null, error: error.message }));
-        child.once("close", (status) => finish({ status, error: timedOut ? "command timed out" : null }));
+        const collect = (target) => (chunk) => {
+            if (settled)
+                return;
+            outputBytes += chunk.length;
+            if (outputBytes > maxCommandOutputBytes) {
+                outputExceeded = true;
+                killProcessGroup(child);
+                return;
+            }
+            target.push(chunk);
+        };
+        child.stdout.on("data", collect(stdout));
+        child.stderr.on("data", collect(stderr));
+        child.once("error", (error) => finish({ status: null, error: error.message, errorCode: error.code ?? null }));
+        child.once("close", (status) => finish({
+            status,
+            error: timedOut ? "command timed out" : outputExceeded ? "command produced too much output" : null,
+            errorCode: null
+        }));
     });
 }

package/dist/server/i18n.js

@@ -95,6 +95,10 @@ const enMessages = {
     UPLOAD_EMPTY: "No file was selected for upload.",
     USERNAME_INVALID: "The username may contain only letters, numbers, dots, hyphens, or underscores.",
     USER_NOT_FOUND: "The user does not exist or is disabled.",
+    WORD_COUNT_FAILED: "TeXcount could not count this source.",
+    WORD_COUNT_SOURCE_INVALID: "Select LaTeX source text to count.",
+    WORD_COUNT_SOURCE_TOO_LARGE: "The selected source is too large to count.",
+    WORD_COUNT_UNAVAILABLE: "TeXcount is not available on this server. Install it from TeX Live and try again.",
     ZIP_DUPLICATE_ENTRY: "The ZIP archive contains a duplicate filename: {{path}}.",
     ZIP_ENTRY_READ_FAILED: "A ZIP archive entry could not be read.",
     ZIP_ENTRY_TOO_LARGE: "The ZIP archive contains a file that exceeds the permitted size.",
@@ -215,6 +219,10 @@ const zhMessages = {
     UPLOAD_EMPTY: "没有选择要上传的文件。",
     USERNAME_INVALID: "用户名只能包含字母、数字、点、横线或下划线。",
     USER_NOT_FOUND: "用户不存在或已被禁用。",
+    WORD_COUNT_FAILED: "TeXcount 无法统计这段源码。",
+    WORD_COUNT_SOURCE_INVALID: "请选择 LaTeX 源码后再统计。",
+    WORD_COUNT_SOURCE_TOO_LARGE: "所选源码过大，无法统计。",
+    WORD_COUNT_UNAVAILABLE: "服务器未安装 TeXcount，请安装 TeX Live 后重试。",
     ZIP_DUPLICATE_ENTRY: "ZIP 压缩包包含重复文件名：{{path}}。",
     ZIP_ENTRY_READ_FAILED: "无法读取 ZIP 压缩包中的文件。",
     ZIP_ENTRY_TOO_LARGE: "ZIP 压缩包中存在超过限制的文件。",

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
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "texlite",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A lightweight local-first collaborative LaTeX workspace",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -28,7 +28,8 @@
     "DESIGN.md",
     "NPM_TESTING.md",
     "LICENSE",
-    "preview.png",
+    "preview-1.png",
+    "preview-2.png",
     "texlite.config.example.json"
   ],
   "engines": {