texlite 0.7.8 → 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/harper.js

@@ -1,144 +1,235 @@
-import { Worker } from "node:worker_threads";
-const setupTimeoutMs = 45_000;
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { maskLatexSource } from "./latexSpellMask.js";
+const commandProbeTimeoutMs = 5_000;
 const lintTimeoutMs = 30_000;
-function withTimeout(operation, timeoutMs, message) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-        operation.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
-    });
+const maxCommandOutputBytes = 8 * 1024 * 1024;
+const maxCachedSourceBytes = 512 * 1024;
+const maxCachedResults = 24;
+const cacheTtlMs = 15_000;
+const unavailableRetryMs = 15_000;
+export class HarperUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HarperUnavailableError";
+    }
+}
+function lintCacheKey(source, filePath) {
+    // Harper selects its parser from the input suffix, so equivalent text in a
+    // .tex and a .sty file must not share a diagnostic result.
+    return createHash("sha256").update(temporaryFileExtension(filePath)).update("\0").update(source).digest("base64url");
+}
+function temporaryFileExtension(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    // Harper selects its TeX parser by extension. Treat source-like companion
+    // files as TeX too; BibTeX keys are intentionally not grammar-checked.
+    return extension === ".tex" || extension === ".sty" || extension === ".cls" ? extension : ".tex";
+}
+function replacementText(suggestion) {
+    const match = /^Replace with:\s*[“"]([\s\S]*)[”"]$/u.exec(suggestion.trim());
+    return match?.[1] ?? null;
+}
+/** Parse `harper-cli lint --format json` output into the browser API shape. */
+export function parseHarperCliOutput(output) {
+    let documents;
+    try {
+        documents = JSON.parse(output);
+    }
+    catch {
+        throw new Error("Harper returned invalid JSON.");
+    }
+    if (!Array.isArray(documents))
+        throw new Error("Harper returned an unexpected result.");
+    const lints = [];
+    for (const document of documents) {
+        if (!Array.isArray(document.lints))
+            continue;
+        for (const lint of document.lints) {
+            const start = lint.span?.char_start;
+            const end = lint.span?.char_end;
+            if (typeof start !== "number" || typeof end !== "number" || !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start)
+                continue;
+            const suggestions = Array.isArray(lint.suggestions)
+                ? lint.suggestions.filter((value) => typeof value === "string")
+                    .map(replacementText).filter((value) => value !== null)
+                : [];
+            lints.push({
+                start,
+                end,
+                problem: typeof lint.matched_text === "string" ? lint.matched_text : "",
+                kind: typeof lint.kind === "string" ? lint.kind : "Grammar",
+                message: typeof lint.message === "string" ? lint.message : "Harper found a writing issue.",
+                suggestions: [...new Set(suggestions)].slice(0, 5)
+            });
+        }
+    }
+    return lints;
 }
 /**
- * One Harper runtime per TexLite server process. Production uses one Node
- * Worker so WASM checks cannot block Fastify or collaboration messages. Source
- * mode (tsx/Vitest) uses the same runtime in-process because the emitted worker
- * entry does not exist until the server build has completed.
+ * Optional host-side Harper integration. `harper-cli` is distributed with
+ * Harper/harper-ls and provides native TeX parsing plus structured fixes,
+ * without bundling a WASM runtime into TexLite.
  */
 export class HarperService {
-    useWorker = import.meta.url.endsWith(".js");
-    linter = null;
-    setupPromise = null;
-    worker = null;
-    nextRequestId = 1;
-    pending = new Map();
+    command;
+    availability = "unknown";
+    lastUnavailableAt = 0;
+    probePromise = null;
     queue = Promise.resolve();
+    inFlight = new Map();
+    cache = new Map();
+    activeChild = null;
+    disposed = false;
+    constructor(command = "harper-cli") {
+        this.command = command;
+    }
     async preload() {
-        await this.ensureRuntime();
+        await this.ensureAvailable();
     }
-    async lint(source) {
-        const operation = this.queue.then(async () => {
-            await this.ensureRuntime();
-            try {
-                return await withTimeout(this.useWorker ? this.lintInWorker(source) : this.lintInProcess(source), lintTimeoutMs, "Harper writing check timed out.");
-            }
-            catch (error) {
-                if (error instanceof Error && error.message === "Harper writing check timed out.")
-                    this.stopFailedWorker(error);
-                throw error;
-            }
-        });
+    async lint(source, filePath = "main.tex") {
+        if (this.disposed)
+            throw new HarperUnavailableError("Harper service stopped.");
+        const key = lintCacheKey(source, filePath);
+        const cacheable = Buffer.byteLength(source, "utf8") <= maxCachedSourceBytes;
+        const cached = cacheable ? this.cachedResult(key) : null;
+        if (cached)
+            return cached;
+        const existing = cacheable ? this.inFlight.get(key) : undefined;
+        if (existing)
+            return existing;
+        const operation = this.queue.then(() => this.lintOnce(source, filePath));
         this.queue = operation.then(() => undefined, () => undefined);
+        if (cacheable) {
+            this.inFlight.set(key, operation);
+            void operation.then((lints) => this.cacheResult(key, lints), () => undefined).finally(() => {
+                if (this.inFlight.get(key) === operation)
+                    this.inFlight.delete(key);
+            });
+        }
         return operation;
     }
     async dispose() {
+        this.disposed = true;
+        this.activeChild?.kill("SIGTERM");
         await this.queue.catch(() => undefined);
-        await this.setupPromise?.catch(() => undefined);
-        const worker = this.worker;
-        this.worker = null;
-        if (worker)
-            await worker.terminate().catch(() => undefined);
-        const linter = this.linter;
-        this.linter = null;
-        if (linter)
-            await linter.dispose().catch(() => undefined);
-        this.setupPromise = null;
-        this.rejectPending(new Error("Harper service stopped."));
+        this.inFlight.clear();
+        this.cache.clear();
     }
-    ensureRuntime() {
-        if (this.setupPromise)
-            return this.setupPromise;
-        if (this.worker || this.linter)
-            return Promise.resolve();
-        this.setupPromise = withTimeout(this.useWorker ? this.startWorker() : this.startInProcess(), setupTimeoutMs, "Harper initialization timed out.")
+    async ensureAvailable() {
+        if (this.availability === "available")
+            return;
+        if (this.availability === "unavailable" && Date.now() - this.lastUnavailableAt < unavailableRetryMs) {
+            throw new HarperUnavailableError(`The optional ${this.command} command is not available.`);
+        }
+        if (this.probePromise)
+            return this.probePromise;
+        this.probePromise = this.runCommand(["--version"], commandProbeTimeoutMs, 64 * 1024)
+            .then(({ code }) => {
+            if (code !== 0)
+                throw new Error(`${this.command} exited with code ${code}.`);
+            this.availability = "available";
+        })
             .catch((error) => {
-            this.stopFailedWorker(error instanceof Error ? error : new Error(String(error)));
-            throw error;
+            this.availability = "unavailable";
+            this.lastUnavailableAt = Date.now();
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new HarperUnavailableError(`The optional ${this.command} command is unavailable: ${detail}`);
         })
-            .finally(() => { this.setupPromise = null; });
-        return this.setupPromise;
+            .finally(() => { this.probePromise = null; });
+        return this.probePromise;
     }
-    async startInProcess() {
-        const { createHarperLinter } = await import("./harperRuntime.js");
-        this.linter = await createHarperLinter();
+    async lintOnce(source, filePath) {
+        await this.ensureAvailable();
+        const directory = await mkdtemp(path.join(tmpdir(), "texlite-harper-"));
+        const input = path.join(directory, `document${temporaryFileExtension(filePath)}`);
+        try {
+            await writeFile(input, maskLatexSource(source), { encoding: "utf8", mode: 0o600 });
+            const { code, stdout, stderr } = await this.runCommand([
+                "lint", "--format", "json", "--quiet",
+                "--user-dict-path", path.join(directory, "dictionary.txt"),
+                "--file-dict-path", path.join(directory, "file-dictionaries"),
+                input
+            ], lintTimeoutMs, maxCommandOutputBytes);
+            // Harper exits with one when it found lints. Any other non-zero status is
+            // a command failure, not a spelling result.
+            if (code !== 0 && code !== 1)
+                throw new Error(stderr.trim() || `${this.command} exited with code ${code}.`);
+            return parseHarperCliOutput(stdout);
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        }
     }
-    startWorker() {
+    cachedResult(key) {
+        const cached = this.cache.get(key);
+        if (!cached || cached.expiresAt < Date.now()) {
+            this.cache.delete(key);
+            return null;
+        }
+        this.cache.delete(key);
+        this.cache.set(key, cached);
+        return cached.lints;
+    }
+    cacheResult(key, lints) {
+        this.cache.set(key, { expiresAt: Date.now() + cacheTtlMs, lints });
+        while (this.cache.size > maxCachedResults) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.cache.delete(oldest);
+        }
+    }
+    runCommand(args, timeoutMs, outputLimit) {
         return new Promise((resolve, reject) => {
-            const worker = new Worker(new URL("./harperWorker.js", import.meta.url), { name: "texlite-harper" });
-            this.worker = worker;
-            const rejectStart = (error) => reject(error);
-            const onInitialMessage = (message) => {
-                if (!("type" in message))
+            let child;
+            try {
+                child = spawn(this.command, args, { stdio: ["ignore", "pipe", "pipe"] });
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            this.activeChild = child;
+            const stdout = [];
+            const stderr = [];
+            let outputBytes = 0;
+            let settled = false;
+            let timer;
+            const finish = (callback) => {
+                if (settled)
                     return;
-                worker.off("message", onInitialMessage);
-                worker.off("error", rejectStart);
-                if (message.type === "ready")
-                    resolve();
-                else
-                    reject(new Error(message.message));
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                if (this.activeChild === child)
+                    this.activeChild = null;
+                callback();
             };
-            worker.on("message", onInitialMessage);
-            worker.once("error", rejectStart);
-            worker.on("message", (message) => this.handleWorkerMessage(message));
-            worker.on("error", (error) => this.stopFailedWorker(error));
-            worker.on("exit", (code) => {
-                if (this.worker !== worker)
+            const fail = (error) => finish(() => reject(error));
+            timer = setTimeout(() => {
+                child.kill("SIGTERM");
+                fail(new Error(`${this.command} timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
+            }, timeoutMs);
+            const collect = (target) => (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > outputLimit) {
+                    child.kill("SIGTERM");
+                    fail(new Error(`${this.command} produced too much output.`));
                     return;
-                this.worker = null;
-                this.rejectPending(new Error(`Harper worker exited unexpectedly with code ${code}.`));
-            });
-        });
-    }
-    lintInWorker(source) {
-        const worker = this.worker;
-        if (!worker)
-            return Promise.reject(new Error("Harper worker is not ready."));
-        const id = this.nextRequestId++;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            worker.postMessage({ id, source });
+                }
+                target.push(chunk);
+            };
+            child.stdout.on("data", collect(stdout));
+            child.stderr.on("data", collect(stderr));
+            child.once("error", (error) => fail(error));
+            child.once("close", (code) => finish(() => resolve({
+                code,
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8")
+            })));
         });
     }
-    async lintInProcess(source) {
-        if (!this.linter)
-            throw new Error("Harper is not ready.");
-        const { collectHarperLints } = await import("./harperRuntime.js");
-        return collectHarperLints(this.linter, source);
-    }
-    handleWorkerMessage(message) {
-        if ("type" in message)
-            return;
-        const pending = this.pending.get(message.id);
-        if (!pending)
-            return;
-        this.pending.delete(message.id);
-        if (message.ok)
-            pending.resolve(message.lints);
-        else
-            pending.reject(new Error(message.message));
-    }
-    stopFailedWorker(error) {
-        const worker = this.worker;
-        this.worker = null;
-        if (worker)
-            void worker.terminate().catch(() => undefined);
-        const linter = this.linter;
-        this.linter = null;
-        if (linter)
-            void linter.dispose().catch(() => undefined);
-        this.rejectPending(error);
-    }
-    rejectPending(error) {
-        for (const pending of this.pending.values())
-            pending.reject(error);
-        this.pending.clear();
-    }
 }

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 压缩包中存在超过限制的文件。",