texlite 0.7.7 → 0.8.0

package/dist/client/assets/{minus-O6pK-6mA.js → minus-DR-ttrx3.js}

@@ -1 +1 @@
-import{j as e}from"./index-zIjCeZFK.js";const n=e("Maximize2",[["polyline",{points:"15 3 21 3 21 9",key:"mznyad"}],["polyline",{points:"9 21 3 21 3 15",key:"1avn1i"}],["line",{x1:"21",x2:"14",y1:"3",y2:"10",key:"ota7mn"}],["line",{x1:"3",x2:"10",y1:"21",y2:"14",key:"1atl0r"}]]);const a=e("Minus",[["path",{d:"M5 12h14",key:"1ays0h"}]]);export{a as M,n as a};
+import{j as e}from"./index-vpWlpUOr.js";const n=e("Maximize2",[["polyline",{points:"15 3 21 3 21 9",key:"mznyad"}],["polyline",{points:"9 21 3 21 3 15",key:"1avn1i"}],["line",{x1:"21",x2:"14",y1:"3",y2:"10",key:"ota7mn"}],["line",{x1:"3",x2:"10",y1:"21",y2:"14",key:"1atl0r"}]]);const a=e("Minus",[["path",{d:"M5 12h14",key:"1ays0h"}]]);export{a as M,n as a};

package/dist/client/assets/spellCheck-Wn7_eF9j.js

@@ -0,0 +1 @@
+import{a as k}from"./index-vpWlpUOr.js";import"./react-BoEjKzFZ.js";const S=5,u=new Map,x=12;let p=!1,f=null;class h extends Error{constructor(){super("A newer writing check replaced this request."),this.name="HarperLintSupersededError"}}function A(t){return t instanceof h}function v(t){const e=[0];let n=0;for(const r of t)n+=r.length,e.push(n);return e}function L(t){return[...new Set(t.map(e=>e.trim()).filter(Boolean))].sort((e,n)=>e.localeCompare(n)).join("\0")}async function C(t,e,n){return(await k(`/api/projects/${t}/spellcheck`,{method:"POST",body:JSON.stringify({path:e,source:n})})).lints}function R(t,e,n){if(!e.problem)return null;const r={from:e.start,to:e.end},o={from:n[e.start]??-1,to:n[e.end]??-1},i=c=>c.from>=0&&c.to>c.from&&c.to<=t.length,a=c=>i(c)&&t.slice(c.from,c.to)===e.problem;return a(o)?o:a(r)?r:null}function $(t,e,n){const r=R(t,e,n);if(!r)return null;const{from:o,to:i}=r,a=t.slice(o,i);if(!a.trim()||!/[A-Za-z]/.test(a)||e.kind==="Formatting")return null;const c=e.kind==="Spelling"||e.kind==="Typo"?"spelling":"grammar",m=e.suggestions.filter((d,s,l)=>s<S&&l.indexOf(d)===s);return{from:o,to:i,word:a,kind:c,message:e.message,suggestions:m}}function g(t,e){let n=2166136261;for(let r=0;r<e.length;r+=1)n^=e.charCodeAt(r),n=Math.imul(n,16777619);return`${t}\0${e.length}:${n>>>0}`}function y(t,e,n){const r=g(t,e),o=u.get(r);return!o||o.path!==t||o.source!==e||o.dictionary!==n?null:(u.delete(r),u.set(r,o),o.issues)}function j(t,e,n,r){const o=g(t,e);for(u.set(o,{path:t,source:e,dictionary:n,issues:r});u.size>x;){const i=u.keys().next().value;if(i===void 0)break;u.delete(i)}}async function q(t,e,n,r="main.tex"){const o=L(e),i=y(r,t,o);if(i)return i;const a=v(t),c=new Set(e.map(s=>s.trim().toLocaleLowerCase("en-US")).filter(Boolean)),m=new Set,d=n.map(s=>$(t,s,a)).filter(s=>!!s).filter(s=>s.kind!=="spelling"||!c.has(s.word.trim().toLocaleLowerCase("en-US"))).filter(s=>{const l=`${s.from}:${s.to}:${s.kind}`;return m.has(l)?!1:(m.add(l),!0)}).sort((s,l)=>s.from-l.from||s.to-l.to);return j(r,t,o,d),d}async function b(t,e,n,r){const o=L(r),i=y(e,n,o);if(i)return i;const a=await C(t,e,n);return q(n,r,a,e)}async function w(){if(p||!f)return;const t=f;f=null,p=!0;try{t.resolve(await b(t.projectId,t.path,t.source,t.customWords))}catch(e){t.reject(e)}finally{p=!1,w()}}function B(t,e,n,r=[]){return new Promise((o,i)=>{f?.reject(new h),f={projectId:t,path:e,source:n,customWords:[...r],resolve:o,reject:i},w()})}export{h as HarperLintSupersededError,A as isHarperLintSupersededError,B as lintLatex,q as mapLatexLints};

package/dist/client/index.html

@@ -10,9 +10,9 @@
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fontsource/iosevka@5.2.5/400.css" />
     <link rel="icon" type="image/svg+xml" href="/logo.svg" />
     <title>TexLite</title>
-    <script type="module" crossorigin src="/assets/index-zIjCeZFK.js"></script>
+    <script type="module" crossorigin src="/assets/index-vpWlpUOr.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-BoEjKzFZ.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-MDwr9W9R.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-CdiutUgf.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/app.js

@@ -50,9 +50,9 @@ export async function buildApp(config, db, options = {}) {
     const latexCompletions = new LatexCompletionService(config);
     const projectOutlines = new ProjectOutlineService(config);
     const harper = new HarperService();
-    // Warm the single server-side runtime without delaying startup. The first
-    // request shares this promise if initialization is still in progress.
-    void harper.preload().catch((error) => app.log.warn({ err: error }, "Harper could not be initialized"));
+    // Probe the optional host Harper CLI without delaying startup. Its absence is
+    // supported: the browser spellchecker remains the writing-check fallback.
+    void harper.preload().catch((error) => app.log.info({ err: error }, "Optional Harper CLI is unavailable"));
     const recordHistory = (projectId, userId, reason, paths) => {
         try {
             return history.record(projectId, userId, reason, paths);

package/dist/server/compiler.js

@@ -9,6 +9,13 @@ import { gunzipSync, gzipSync } from "node:zlib";
 import { listProjectFilesAsync, outputRoot, resolveSourcePath, safeRelativePath, texFileStem } from "./files.js";
 import { parseCompileDiagnostics } from "./compileDiagnostics.js";
 import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
+/** A controlled stop is a normal compile outcome, never a server error. */
+export class CompileCancelledError extends Error {
+    constructor() {
+        super("Compilation was cancelled.");
+        this.name = "CompileCancelledError";
+    }
+}
 export class CompileQueue {
     concurrency;
     running = 0;
@@ -16,16 +23,39 @@ export class CompileQueue {
     constructor(concurrency) {
         this.concurrency = concurrency;
     }
-    add(job) {
+    add(job, signal) {
         return new Promise((resolve, reject) => {
-            this.pending.push(async () => {
+            let started = false;
+            const cancelPending = () => {
+                if (started)
+                    return;
+                const index = this.pending.indexOf(task);
+                if (index < 0)
+                    return;
+                this.pending.splice(index, 1);
+                reject(new CompileCancelledError());
+                this.drain();
+            };
+            const task = async () => {
+                started = true;
+                signal?.removeEventListener("abort", cancelPending);
+                if (signal?.aborted) {
+                    reject(new CompileCancelledError());
+                    return;
+                }
                 try {
                     resolve(await job());
                 }
                 catch (error) {
                     reject(error);
                 }
-            });
+            };
+            if (signal?.aborted) {
+                reject(new CompileCancelledError());
+                return;
+            }
+            this.pending.push(task);
+            signal?.addEventListener("abort", cancelPending, { once: true });
             this.drain();
         });
     }
@@ -94,8 +124,42 @@ export class ProjectCompileCoordinator {
         }
         return managed.promise;
     }
+    /**
+     * Stop the active target and discard any newer pending request for it. A
+     * target has one writer-visible compile at a time, so cancelling the whole
+     * target avoids immediately starting a stale follow-up compilation.
+     */
+    cancel(projectId, target) {
+        const targetKey = `${projectId}\0${target ?? ""}`;
+        const state = this.targets.get(targetKey);
+        const active = state?.active;
+        if (!active)
+            return null;
+        const status = active.started ? "running" : "queued";
+        active.controller.abort();
+        if (state?.pending) {
+            const pending = state.pending;
+            state.pending = null;
+            pending.controller.abort();
+            pending.input.onDiscarded("cancelled");
+            pending.resolve(cancelledCompileResult(pending.input));
+        }
+        return { runId: active.input.runId, status };
+    }
     start(targetKey, state, job) {
-        void this.queue.add(job.input.execute).then(job.resolve, job.reject).finally(() => {
+        void this.queue.add(async () => {
+            job.started = true;
+            if (job.controller.signal.aborted)
+                throw new CompileCancelledError();
+            return await job.input.execute(job.controller.signal);
+        }, job.controller.signal).then(job.resolve, (error) => {
+            if (error instanceof CompileCancelledError) {
+                job.input.onCancelled?.();
+                job.resolve(cancelledCompileResult(job.input));
+                return;
+            }
+            job.reject(error);
+        }).finally(() => {
             if (state.active !== job)
                 return;
             state.active = null;
@@ -122,7 +186,19 @@ function deferredJob(input) {
         resolve = resolvePromise;
         reject = rejectPromise;
     });
-    return { input, promise, resolve, reject };
+    return { input, promise, resolve, reject, controller: new AbortController(), started: false };
+}
+function cancelledCompileResult(input) {
+    return {
+        runId: input.runId,
+        revision: input.revision,
+        ok: false,
+        cancelled: true,
+        log: new CompileCancelledError().message,
+        diagnostics: { warnings: [], errors: [] },
+        pdfPath: null,
+        synctexPath: null
+    };
 }
 export async function captureCompileSnapshot(config, projectId, runId, settings) {
     const root = compileRunRoot(config, projectId, runId);
@@ -532,7 +608,10 @@ function rewriteSynctexSource(synctexPath, cacheSource, snapshotSource) {
     if (rewritten !== original)
         fs.writeFileSync(synctexPath, gzipSync(Buffer.from(rewritten)), { mode: 0o600 });
 }
-export async function compileProject(config, snapshot, mainFileInput, engine, latexmkrcInput) {
+export async function compileProject(config, snapshot, mainFileInput, engine, latexmkrcInput, options = {}) {
+    const { signal } = options;
+    if (signal?.aborted)
+        return cancelledCompileResultForProject();
     const mainFile = safeRelativePath(mainFileInput);
     if (!/\.tex$/i.test(mainFile))
         throw new Error("The main file must have a .tex extension");
@@ -548,6 +627,10 @@ export async function compileProject(config, snapshot, mainFileInput, engine, la
     const cacheStartedAt = performance.now();
     const cache = prepareCompileCache(config, snapshot, mainFile, engine, latexmkrc);
     const cacheSyncMs = performance.now() - cacheStartedAt;
+    if (signal?.aborted)
+        return cancelledCompileResultForProject({
+            cacheSyncMs, latexmkMs: 0, artifactCopyMs: 0, totalMs: performance.now() - startedAt
+        });
     const cwd = cache.sourceDir;
     const outDir = cache.outputDir;
     const engineFlag = engine === "xelatex" ? "-xelatex" : engine === "lualatex" ? "-lualatex" : "-pdf";
@@ -578,6 +661,7 @@ export async function compileProject(config, snapshot, mainFileInput, engine, la
             stdio: ["ignore", "pipe", "pipe"]
         });
         let log = "";
+        let cancelled = false;
         const append = (chunk) => {
             log += chunk.toString("utf8");
             if (log.length > 2_000_000)
@@ -585,19 +669,46 @@ export async function compileProject(config, snapshot, mainFileInput, engine, la
         };
         child.stdout.on("data", append);
         child.stderr.on("data", append);
-        child.on("error", reject);
-        const timeout = setTimeout(() => {
+        let timeout = null;
+        const cancel = () => {
+            if (cancelled)
+                return;
+            cancelled = true;
+            log += "\nCompilation was cancelled.\n";
+            killProcessGroup(child);
+        };
+        const removeAbortListener = () => signal?.removeEventListener("abort", cancel);
+        child.once("error", (error) => {
+            if (timeout)
+                clearTimeout(timeout);
+            removeAbortListener();
+            reject(error);
+        });
+        timeout = setTimeout(() => {
+            if (cancelled)
+                return;
             log += `\nCompilation exceeded ${config.compileTimeoutMs / 1000} seconds and was terminated.\n`;
             killProcessGroup(child);
         }, config.compileTimeoutMs);
+        if (signal?.aborted)
+            cancel();
+        else
+            signal?.addEventListener("abort", cancel, { once: true });
         child.on("close", (code) => {
-            clearTimeout(timeout);
-            resolve({ code, log });
+            if (timeout)
+                clearTimeout(timeout);
+            removeAbortListener();
+            resolve({ code, log, cancelled });
         });
     });
     const latexmkMs = performance.now() - latexmkStartedAt;
     const basename = texFileStem(mainFile);
     const cachedPdf = path.join(outDir, `${basename}.pdf`);
+    if (processResult.cancelled || signal?.aborted) {
+        return cancelledCompileResultForProject({
+            cacheSyncMs, latexmkMs, artifactCopyMs: 0, totalMs: performance.now() - startedAt
+        }, processResult.log);
+    }
     const ok = processResult.code === 0 && fs.existsSync(cachedPdf);
     const diagnostics = parseCompileDiagnostics(processResult.log, ok ? "succeeded" : "failed");
     if (!ok) {
@@ -606,6 +717,10 @@ export async function compileProject(config, snapshot, mainFileInput, engine, la
             timings: { cacheSyncMs, latexmkMs, artifactCopyMs: 0, totalMs: performance.now() - startedAt }
         };
     }
+    if (signal?.aborted)
+        return cancelledCompileResultForProject({
+            cacheSyncMs, latexmkMs, artifactCopyMs: 0, totalMs: performance.now() - startedAt
+        });
     const artifactStartedAt = performance.now();
     const artifacts = materializeCompileArtifacts(cache, snapshot, basename);
     const artifactCopyMs = performance.now() - artifactStartedAt;
@@ -614,3 +729,17 @@ export async function compileProject(config, snapshot, mainFileInput, engine, la
         timings: { cacheSyncMs, latexmkMs, artifactCopyMs, totalMs: performance.now() - startedAt }
     };
 }
+function cancelledCompileResultForProject(timings, log = "") {
+    const message = log.includes("Compilation was cancelled.")
+        ? log
+        : `${log}${log && !log.endsWith("\n") ? "\n" : ""}Compilation was cancelled.\n`;
+    return {
+        ok: false,
+        cancelled: true,
+        log: message,
+        diagnostics: parseCompileDiagnostics(message, "failed"),
+        pdfPath: null,
+        synctexPath: null,
+        ...(timings ? { timings } : {})
+    };
+}

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();
-    }
 }