texlite 0.8.3 → 0.9.0

package/dist/server/history.js

@@ -5,6 +5,12 @@ import { assertNoSourceSymlinks, listProjectFiles, outputRoot, projectRoot, reso
 import { httpError } from "./http.js";
 import { MAX_TEXT_PREVIEW_BYTES } from "./limits.js";
 const AUTOSAVE_COALESCE_MS = 2 * 60_000;
+// Logical stored payload; SQLite pages, indexes and WAL are shared database overhead.
+function historyMetadataBytes(row) {
+    return Object.values(row).reduce((sum, value) => sum + (typeof value === "string" ? Buffer.byteLength(value, "utf8") : 0), 0);
+}
+const DEFAULT_HISTORY_PAGE_SIZE = 100;
+const MAX_HISTORY_PAGE_SIZE = 100;
 export class ProjectHistoryService {
     config;
     db;
@@ -12,7 +18,7 @@ export class ProjectHistoryService {
         this.config = config;
         this.db = db;
     }
-    record(projectId, authorId, reason, changedRoots) {
+    record(projectId, authorId, reason, changedRoots, options = {}) {
         const project = this.project(projectId);
         const previous = this.latestRow(projectId);
         const previousManifest = this.baseline(projectId) ?? (previous ? parseManifest(previous.manifest_json) : null);
@@ -38,17 +44,19 @@ export class ProjectHistoryService {
             return null;
         }
         const createdAt = new Date().toISOString();
-        if (reason === "autosave" && previous?.reason === "autosave" && !previous.label && previous.author_id === authorId
+        if (reason === "autosave" && previous?.reason === "autosave" && !previous.label
             && Date.parse(createdAt) - Date.parse(previous.created_at) < AUTOSAVE_COALESCE_MS) {
             const merged = [...new Set([...parseStringArray(previous.changed_paths_json), ...changedPaths])].sort();
             this.db.prepare(`UPDATE project_history_versions
-        SET manifest_json = ?, changed_paths_json = ? WHERE id = ?`)
-                .run(JSON.stringify(manifest), JSON.stringify(merged), previous.id);
+        SET manifest_json = ?, changed_paths_json = ?, author_id = ? WHERE id = ?`)
+                .run(JSON.stringify(manifest), JSON.stringify(merged), previous.author_id === authorId ? authorId : null, previous.id);
             this.saveBaseline(projectId, manifest);
-            this.removeUnreferencedObjects(projectId, new Set(previousManifest
-                ? Object.values(previousManifest.files).map((file) => file.digest)
-                : []));
-            this.pruneVersions(projectId);
+            if (!options.deferRetention) {
+                this.removeUnreferencedObjects(projectId, new Set(previousManifest
+                    ? Object.values(previousManifest.files).map((file) => file.digest)
+                    : []));
+                this.pruneVersions(projectId);
+            }
             return this.version(previous.id);
         }
         const id = randomUUID();
@@ -57,7 +65,8 @@ export class ProjectHistoryService {
       VALUES (?, ?, ?, ?, ?, ?, ?)`)
             .run(id, projectId, authorId, reason, JSON.stringify(manifest), JSON.stringify(changedPaths), createdAt);
         this.saveBaseline(projectId, manifest);
-        this.pruneVersions(projectId);
+        if (!options.deferRetention)
+            this.pruneVersions(projectId);
         return this.version(id);
     }
     list(projectId, limit = 100) {
@@ -67,13 +76,50 @@ export class ProjectHistoryService {
             .all(projectId, Math.min(200, Math.max(1, limit)));
         return rows.map((row) => versionJson(row));
     }
+    /**
+     * List immutable recovery snapshots from newest to oldest. Cursor pagination
+     * is preferable to offsets here: concurrent saves/deletions cannot shift an
+     * already loaded page or make the next request repeat a snapshot.
+    */
+    listPage(projectId, limit = DEFAULT_HISTORY_PAGE_SIZE, cursorInput) {
+        const requestedLimit = Number.isFinite(limit) ? Math.floor(limit) : DEFAULT_HISTORY_PAGE_SIZE;
+        const limitValue = Math.min(MAX_HISTORY_PAGE_SIZE, Math.max(1, requestedLimit));
+        const cursor = cursorInput === undefined ? null : decodeHistoryCursor(cursorInput);
+        if (cursorInput !== undefined && !cursor)
+            throw httpError(400, "REQUEST_INVALID");
+        const values = [projectId];
+        let cursorFilter = "";
+        if (cursor) {
+            cursorFilter = "AND (history.created_at < ? OR (history.created_at = ? AND history.rowid < ?))";
+            values.push(cursor.createdAt, cursor.createdAt, cursor.rowId);
+        }
+        values.push(limitValue + 1);
+        const rows = this.db.prepare(`SELECT history.*, history.rowid AS history_rowid,
+      user.username AS author_username, user.display_name AS author_name
+      FROM project_history_versions history LEFT JOIN users user ON user.id = history.author_id
+      WHERE history.project_id = ? ${cursorFilter}
+      ORDER BY history.created_at DESC, history.rowid DESC LIMIT ?`)
+            .all(...values);
+        const pageRows = rows.slice(0, limitValue);
+        return {
+            versions: pageRows.map((row) => versionJson(row)),
+            nextCursor: rows.length > limitValue && pageRows.length > 0 ? encodeHistoryCursor(pageRows.at(-1)) : null
+        };
+    }
     stats(projectId) {
-        const rows = this.db.prepare(`SELECT reason, label, manifest_json FROM project_history_versions
-      WHERE project_id = ?`).all(projectId);
+        const rows = this.db.prepare(`SELECT * FROM project_history_versions
+      WHERE project_id = ? ORDER BY created_at DESC, rowid DESC`).all(projectId);
         const objects = new Map();
+        const protectedObjects = new Map();
+        let metadataBytes = 0;
+        let protectedMetadataBytes = 0;
         let ordinaryVersionCount = 0;
         let labeledVersionCount = 0;
         for (const row of rows) {
+            const protectedVersion = row === rows[0] || row.reason === "initial" || Boolean(row.label);
+            metadataBytes += historyMetadataBytes(row);
+            if (protectedVersion)
+                protectedMetadataBytes += historyMetadataBytes(row);
             if (row.label)
                 labeledVersionCount += 1;
             else if (row.reason !== "initial")
@@ -81,13 +127,19 @@ export class ProjectHistoryService {
             for (const file of Object.values(parseManifest(row.manifest_json).files)) {
                 if (!objects.has(file.digest))
                     objects.set(file.digest, file.size);
+                if (protectedVersion)
+                    protectedObjects.set(file.digest, file.size);
             }
         }
         const baseline = this.baseline(projectId);
         if (baseline) {
+            const baselineBytes = Buffer.byteLength(JSON.stringify(baseline), "utf8");
+            metadataBytes += baselineBytes;
+            protectedMetadataBytes += baselineBytes;
             for (const file of Object.values(baseline.files)) {
                 if (!objects.has(file.digest))
                     objects.set(file.digest, file.size);
+                protectedObjects.set(file.digest, file.size);
             }
         }
         const objectBytes = [...objects.values()].reduce((sum, size) => sum + size, 0);
@@ -97,13 +149,21 @@ export class ProjectHistoryService {
             labeledVersionCount,
             objectCount: objects.size,
             objectBytes,
+            metadataBytes,
+            totalBytes: objectBytes + metadataBytes,
+            protectedBytes: [...protectedObjects.values()].reduce((sum, size) => sum + size, protectedMetadataBytes),
             maxVersions: this.config.historyMaxVersions,
             maxStorageBytes: this.config.historyMaxStorageBytes,
-            storageLimitExceeded: objectBytes > this.config.historyMaxStorageBytes
+            storageLimitExceeded: objectBytes + metadataBytes > this.config.historyMaxStorageBytes
         };
     }
     enforceRetention(projectId) {
         this.pruneVersions(projectId);
+        // Deferred autosave maintenance can leave an object from a coalesced
+        // version without any manifest referring to it. Scan the small
+        // content-addressed object store here (never in the save path) so a
+        // restart also recovers objects left behind before a timer could run.
+        this.removeUnreferencedObjects(projectId, this.storedObjectDigests(projectId));
     }
     deleteVersion(projectId, versionId) {
         const row = this.db.prepare("SELECT id, manifest_json FROM project_history_versions WHERE id = ? AND project_id = ?")
@@ -151,6 +211,14 @@ export class ProjectHistoryService {
         }
         this.assertRestoreTargetIsFile(projectId, filePath);
     }
+    previousVersion(projectId, versionId) {
+        const row = this.db.prepare(`SELECT older.id FROM project_history_versions older
+      JOIN project_history_versions selected ON selected.id = ? AND selected.project_id = older.project_id
+      WHERE older.project_id = ? AND (older.created_at < selected.created_at
+        OR (older.created_at = selected.created_at AND older.rowid < selected.rowid))
+      ORDER BY older.created_at DESC, older.rowid DESC LIMIT 1`).get(versionId, projectId);
+        return row ? this.version(row.id, projectId) : null;
+    }
     setLabel(projectId, versionId, label) {
         const result = this.db.prepare("UPDATE project_history_versions SET label = ? WHERE id = ? AND project_id = ?")
             .run(label, versionId, projectId);
@@ -272,8 +340,25 @@ export class ProjectHistoryService {
             throw new Error("Invalid history object digest");
         return path.join(outputRoot(this.config, projectId), ".texlite", "history", "objects", digest.slice(0, 2), digest);
     }
+    storedObjectDigests(projectId) {
+        const objectsRoot = path.join(outputRoot(this.config, projectId), ".texlite", "history", "objects");
+        if (!fs.existsSync(objectsRoot))
+            return new Set();
+        const digests = new Set();
+        for (const prefix of fs.readdirSync(objectsRoot, { withFileTypes: true })) {
+            if (!prefix.isDirectory() || !/^[a-f0-9]{2}$/.test(prefix.name))
+                continue;
+            const prefixPath = path.join(objectsRoot, prefix.name);
+            for (const entry of fs.readdirSync(prefixPath, { withFileTypes: true })) {
+                if (entry.isFile() && /^[a-f0-9]{64}$/.test(entry.name) && entry.name.startsWith(prefix.name)) {
+                    digests.add(entry.name);
+                }
+            }
+        }
+        return digests;
+    }
     pruneVersions(projectId) {
-        const rows = this.db.prepare(`SELECT id, reason, label, manifest_json, created_at
+        const rows = this.db.prepare(`SELECT *
       FROM project_history_versions WHERE project_id = ?
       ORDER BY created_at DESC, rowid DESC`).all(projectId);
         if (!rows.length)
@@ -299,19 +384,22 @@ export class ProjectHistoryService {
                     sizeMap.set(file.digest, file.size);
             }
         }
-        let currentObjectBytes = 0;
+        let retainedBytes = rows.reduce((sum, row) => sum + historyMetadataBytes(row), 0)
+            + (baseline ? Buffer.byteLength(JSON.stringify(baseline), "utf8") : 0);
         for (const [digest, count] of refCounts.entries()) {
             if (count > 0)
-                currentObjectBytes += sizeMap.get(digest) ?? 0;
+                retainedBytes += sizeMap.get(digest) ?? 0;
         }
         const latestId = rows[0]?.id;
         // Ordinary versions eligible for version count capping (ordered newest to oldest)
         const ordinaryDesc = rows.filter((row) => row.label === null && row.reason !== "initial");
         const toDeleteIds = new Set();
+        const rowsById = new Map(rows.map((row) => [row.id, row]));
         const removeVersionRefs = (versionId) => {
             if (toDeleteIds.has(versionId))
                 return;
             toDeleteIds.add(versionId);
+            retainedBytes -= historyMetadataBytes(rowsById.get(versionId));
             const manifest = manifests.get(versionId);
             if (!manifest)
                 return;
@@ -320,7 +408,7 @@ export class ProjectHistoryService {
                 if (count !== undefined) {
                     if (count === 1) {
                         refCounts.set(file.digest, 0);
-                        currentObjectBytes -= sizeMap.get(file.digest) ?? 0;
+                        retainedBytes -= sizeMap.get(file.digest) ?? 0;
                     }
                     else if (count > 1) {
                         refCounts.set(file.digest, count - 1);
@@ -328,19 +416,19 @@ export class ProjectHistoryService {
                 }
             }
         };
-        // 1. Cap by historyMaxVersions (prune excess ordinary versions from newest to oldest offset)
-        if (ordinaryDesc.length > this.config.historyMaxVersions) {
+        // 1. Cap by historyMaxVersions (prune excess ordinary versions when configured; 0 = unlimited)
+        if (this.config.historyMaxVersions > 0 && ordinaryDesc.length > this.config.historyMaxVersions) {
             const obsolete = ordinaryDesc.slice(this.config.historyMaxVersions);
             for (const row of obsolete)
                 removeVersionRefs(row.id);
         }
         // 2. Cap by historyMaxStorageBytes (prune remaining eligible versions from oldest to newest)
-        if (currentObjectBytes > this.config.historyMaxStorageBytes) {
+        if (retainedBytes > this.config.historyMaxStorageBytes) {
             const remainingEligibleAsc = ordinaryDesc
                 .filter((row) => row.id !== latestId && !toDeleteIds.has(row.id))
                 .reverse();
             for (const row of remainingEligibleAsc) {
-                if (currentObjectBytes <= this.config.historyMaxStorageBytes)
+                if (retainedBytes <= this.config.historyMaxStorageBytes)
                     break;
                 removeVersionRefs(row.id);
             }
@@ -456,6 +544,34 @@ function parseStringArray(value) {
         return [];
     }
 }
+/**
+ * Keep cursors opaque so the public API is free to change its physical
+ * ordering later.  `rowid` breaks ties for snapshots written in the same
+ * millisecond, which is common for file operations touching multiple paths.
+ */
+function encodeHistoryCursor(row) {
+    return Buffer.from(JSON.stringify({ createdAt: row.created_at, rowId: row.history_rowid }), "utf8").toString("base64url");
+}
+function decodeHistoryCursor(value) {
+    // Cursors are generated by this service and normally only a few dozen
+    // characters long.  Bound input before decoding to keep malformed query
+    // strings cheap to reject.
+    if (value.length === 0 || value.length > 256)
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+        const { createdAt, rowId } = parsed;
+        if (typeof createdAt !== "string" || typeof rowId !== "number" || !Number.isSafeInteger(rowId) || rowId <= 0)
+            return null;
+        const timestamp = Date.parse(createdAt);
+        return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === createdAt
+            ? { createdAt, rowId }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 function changedManifestPaths(previous, next) {
     const paths = new Set([...Object.keys(previous.files), ...Object.keys(next.files)]);
     return [...paths].filter((filePath) => previous.files[filePath]?.digest !== next.files[filePath]?.digest).sort();

package/dist/server/historyRetention.js

@@ -0,0 +1,37 @@
+/**
+ * Coalesces non-critical history retention work. A history version is already
+ * durable before this scheduler runs; delaying maintenance can only leave
+ * extra old versions/objects temporarily, never lose a recoverable version.
+ */
+export const HISTORY_RETENTION_DELAY_MS = 30_000;
+export class HistoryRetentionScheduler {
+    history;
+    timers = new Map();
+    delayMs;
+    onError;
+    constructor(history, options = {}) {
+        this.history = history;
+        this.delayMs = options.delayMs ?? HISTORY_RETENTION_DELAY_MS;
+        this.onError = options.onError;
+    }
+    schedule(projectId) {
+        if (this.timers.has(projectId))
+            return;
+        const timer = setTimeout(() => {
+            this.timers.delete(projectId);
+            try {
+                this.history.enforceRetention(projectId);
+            }
+            catch (error) {
+                this.onError?.(error, projectId);
+            }
+        }, this.delayMs);
+        timer.unref?.();
+        this.timers.set(projectId, timer);
+    }
+    dispose() {
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+    }
+}

package/dist/server/i18n.js

@@ -48,6 +48,7 @@ const enMessages = {
     HISTORY_FILE_PREVIEW_UNSUPPORTED: "This historical file cannot be compared as text.",
     HISTORY_TARGET_CONFLICT: "The historical version cannot be restored to the requested path.",
     HISTORY_VERSION_NOT_FOUND: "The history version does not exist.",
+    SELECTION_HISTORY_SOURCE_CHANGED: "The source changed while opening selection history. Wait for synchronization, then select the passage and open its history again.",
     INVALID_PATH: "The file path is invalid.",
     LAST_ADMIN: "At least one active administrator must remain.",
     LATEXMKRC_DISABLED: "Project latexmkrc files are disabled by the administrator.",
@@ -59,6 +60,7 @@ const enMessages = {
     MAIN_FILE_INVALID: "The main document must be an existing .tex file.",
     MAIN_FILE_NOT_FOUND: "The selected main document does not exist.",
     MEMBERS_MANAGE_FORBIDDEN: "Only the project owner can manage members.",
+    MENTION_NOT_FOUND: "The mention notification does not exist.",
     MOVE_INTO_SELF: "A folder cannot be moved into itself.",
     OWNER_MEMBER_FORBIDDEN: "The project owner cannot be added as a member.",
     PASSWORD_TOO_SHORT: "The password must contain at least {{minLength}} characters.",
@@ -174,6 +176,7 @@ const zhMessages = {
     HISTORY_FILE_PREVIEW_UNSUPPORTED: "该历史文件不能作为文本比较。",
     HISTORY_TARGET_CONFLICT: "无法将历史版本恢复到所请求的路径。",
     HISTORY_VERSION_NOT_FOUND: "历史版本不存在。",
+    SELECTION_HISTORY_SOURCE_CHANGED: "打开选区历史时源码已发生变化。请等待同步完成，重新选择文本后再打开历史。",
     INVALID_PATH: "文件路径无效。",
     LAST_ADMIN: "系统必须保留至少一名可用管理员。",
     LATEXMKRC_DISABLED: "管理员已禁用项目级 latexmkrc。",
@@ -185,6 +188,7 @@ const zhMessages = {
     MAIN_FILE_INVALID: "主文档必须是存在的 .tex 文件。",
     MAIN_FILE_NOT_FOUND: "所选主文档不存在。",
     MEMBERS_MANAGE_FORBIDDEN: "只有项目所有者可以管理成员。",
+    MENTION_NOT_FOUND: "@ 提醒不存在。",
     MOVE_INTO_SELF: "不能把文件夹移动到自身内部。",
     OWNER_MEMBER_FORBIDDEN: "项目所有者不能作为成员添加。",
     PASSWORD_TOO_SHORT: "密码至少需要 {{minLength}} 个字符。",

package/dist/server/index.js

@@ -5,12 +5,16 @@ import { activeAdminCount, openDatabase } from "./db.js";
 import { buildApp } from "./app.js";
 import { assertEnvironment } from "./environment.js";
 import { acquireDataDirectoryLock } from "./instanceLock.js";
+import { LogRotation } from "./logRotation.js";
 export async function startServer(configPath) {
     const config = loadConfig(configPath);
     const lock = acquireDataDirectoryLock(config);
     let db = null;
     let app = null;
+    const logs = process.env.TEXLITE_MANAGED_LOGS === "1"
+        ? new LogRotation(config.dataDir, (error) => console.error("TexLite log rotation failed:", error)) : null;
     try {
+        await logs?.start();
         const environment = await assertEnvironment(config);
         db = openDatabase(config);
         if (activeAdminCount(db) === 0) {
@@ -34,6 +38,7 @@ export async function startServer(configPath) {
                         db?.close();
                     }
                     finally {
+                        await logs?.stop();
                         lock.release();
                     }
                 }
@@ -50,6 +55,7 @@ export async function startServer(configPath) {
                 db?.close();
             }
             finally {
+                await logs?.stop();
                 lock.release();
             }
         }

package/dist/server/latexCompletion.js

@@ -5,6 +5,7 @@ const definitionExtensions = /\.(?:tex|sty|cls|def|cfg|dtx|ins)$/i;
 const maxIndexedFileBytes = 3 * 1024 * 1024;
 const maxIndexedBytes = 24 * 1024 * 1024;
 const maxIndexedFiles = 500;
+const maxCachedProjects = 64;
 // Core LaTeX commands are kept in the completion index even when the project
 // has not loaded a package-specific definition yet.  Keep the catalogue
 // grouped by purpose so missing primitives are easy to spot and extend.
@@ -255,7 +256,13 @@ export class LatexCompletionService {
         const existing = this.pending.get(projectId);
         if (existing)
             return existing;
-        const request = this.buildIncremental(projectId).finally(() => {
+        const request = this.buildIncremental(projectId)
+            // Do not retain a partial per-file cache when a project scan fails.
+            .catch((error) => {
+            this.invalidate(projectId);
+            throw error;
+        })
+            .finally(() => {
             if (this.pending.get(projectId) === request)
                 this.pending.delete(projectId);
         });
@@ -269,21 +276,22 @@ export class LatexCompletionService {
     stats() {
         return {
             cachedProjects: this.resultCache.size,
+            cachedSymbolProjects: this.cache.size,
             pending: this.pending.size,
             cachedFiles: [...this.cache.values()].reduce((total, files) => total + files.size, 0)
         };
     }
     async buildIncremental(projectId) {
         const index = standardIndex();
-        const projectCache = this.cache.get(projectId) ?? new Map();
-        this.cache.set(projectId, projectCache);
         const allEntries = (await listProjectFilesAsync(this.config, projectId)).filter((entry) => entry.type === "file").slice(0, maxIndexedFiles);
         const signature = allEntries.map((entry) => `${entry.path}:${entry.size ?? 0}:${entry.mtimeMs ?? 0}`).sort().join("\n");
         const cachedResult = this.resultCache.get(projectId);
         if (cachedResult?.signature === signature) {
-            cachedResult.touched = Date.now();
+            this.touch(projectId);
             return cachedResult.index;
         }
+        const projectCache = this.cache.get(projectId) ?? new Map();
+        this.cache.set(projectId, projectCache);
         const livePaths = new Set(allEntries.map((entry) => entry.path));
         for (const cachedPath of [...projectCache.keys()])
             if (!livePaths.has(cachedPath))
@@ -319,14 +327,33 @@ export class LatexCompletionService {
             commands: sorted(index.commands), environments: sorted(index.environments), labels: sorted(index.labels),
             citations: sorted(index.citations), packages: sorted(index.packages), files: sorted(index.files)
         };
-        this.resultCache.set(projectId, { signature, index: result, touched: Date.now() });
-        if (this.resultCache.size > 64) {
-            const oldest = [...this.resultCache.entries()].sort((left, right) => left[1].touched - right[1].touched)[0];
-            if (oldest)
-                this.resultCache.delete(oldest[0]);
-        }
+        this.resultCache.set(projectId, { signature, index: result });
+        this.touch(projectId);
+        this.evictLeastRecentlyUsedProjects();
         return result;
     }
+    /** Keep result and per-file symbol caches on the same project-level LRU. */
+    touch(projectId) {
+        const result = this.resultCache.get(projectId);
+        if (result) {
+            this.resultCache.delete(projectId);
+            this.resultCache.set(projectId, result);
+        }
+        const symbols = this.cache.get(projectId);
+        if (symbols) {
+            this.cache.delete(projectId);
+            this.cache.set(projectId, symbols);
+        }
+    }
+    evictLeastRecentlyUsedProjects() {
+        while (this.resultCache.size > maxCachedProjects) {
+            const oldestProjectId = this.resultCache.keys().next().value;
+            if (!oldestProjectId)
+                return;
+            this.resultCache.delete(oldestProjectId);
+            this.cache.delete(oldestProjectId);
+        }
+    }
 }
 function mergeIndex(target, source) {
     for (const value of source.commands.values())

package/dist/server/logRotation.js

@@ -0,0 +1,82 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const LOG_MAX_BYTES = 10 * 1024 * 1024;
+export const LOG_CHECK_INTERVAL_MS = 60_000;
+const LOG_BACKUPS = 3;
+export function managedLogPaths(dataDir) {
+    const directory = path.resolve(dataDir, "logs");
+    return { stdout: path.join(directory, "stdout.log"), stderr: path.join(directory, "stderr.log") };
+}
+/** PM2 owns the open descriptors: copy/truncate keeps them valid across rotation. */
+export class LogRotation {
+    dataDir;
+    onError;
+    maxBytes;
+    pending = null;
+    timer = null;
+    stopped = false;
+    constructor(dataDir, onError, maxBytes = LOG_MAX_BYTES) {
+        this.dataDir = dataDir;
+        this.onError = onError;
+        this.maxBytes = maxBytes;
+    }
+    async start() {
+        await this.check();
+        if (!this.stopped && !this.timer) {
+            this.timer = setInterval(() => { void this.check(); }, LOG_CHECK_INTERVAL_MS);
+            this.timer.unref();
+        }
+    }
+    check() {
+        if (this.stopped)
+            return Promise.resolve();
+        if (this.pending)
+            return this.pending;
+        this.pending = this.rotateLogs().finally(() => { this.pending = null; });
+        return this.pending;
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        await this.pending;
+    }
+    async rotateLogs() {
+        for (const file of Object.values(managedLogPaths(this.dataDir))) {
+            try {
+                await this.rotate(file);
+            }
+            catch (error) {
+                this.onError(error);
+            }
+        }
+    }
+    async rotate(file) {
+        const stat = await fs.lstat(file).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!stat?.isFile() || stat.size < this.maxBytes)
+            return;
+        const temporary = `${file}.rotate.tmp`;
+        try {
+            // Do not truncate until a complete backup has been successfully published.
+            await fs.copyFile(file, temporary);
+            await fs.rm(`${file}.${LOG_BACKUPS}`, { force: true });
+            for (let index = LOG_BACKUPS - 1; index >= 1; index--) {
+                await fs.rename(`${file}.${index}`, `${file}.${index + 1}`).catch((error) => {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                });
+            }
+            await fs.rename(temporary, `${file}.1`);
+            // Writes between the copy and truncate can be lost; these are diagnostic logs.
+            await fs.truncate(file, 0);
+        }
+        finally {
+            await fs.rm(temporary, { force: true });
+        }
+    }
+}

package/dist/server/lucideIcons.js

@@ -1,46 +1,45 @@
-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();
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { normalizeLucideIconName } from "../shared/projectIcons.js";
+// The source and compiled server resolve this to the same package-local
+// directory: <package>/dist/shared/lucide-icons.  The build script creates
+// those SVGs from the installed client dependency, keeping React and the
+// complete Lucide component catalogue out of the long-lived server process.
+const staticIconDirectory = fileURLToPath(new URL("../../dist/shared/lucide-icons/", import.meta.url));
+const svgCache = new Map();
+function staticIconPath(name) {
+    return path.join(staticIconDirectory, `${name}.svg`);
 }
-// `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);
+function staticIconExists(name) {
+    try {
+        return fs.statSync(staticIconPath(name)).isFile();
+    }
+    catch {
+        return false;
+    }
 }
-const renderedIcons = new Map();
-/** Resolve an official Lucide icon slug to an installed icon. */
+/** Resolve an official Lucide slug only when a generated static SVG exists. */
 export function resolveLucideIconName(value) {
     const name = normalizeLucideIconName(value);
-    return name && iconComponents.has(name) ? name : null;
+    return name && staticIconExists(name) ? name : null;
 }
-/** Render a verified Lucide icon once for use as a small, cacheable SVG mask. */
+/** Read a verified static SVG once for use as a small, cacheable CSS mask. */
 export async function lucideIconSvg(name) {
-    const Icon = iconComponents.get(name);
-    if (!Icon)
-        return null;
-    const cached = renderedIcons.get(name);
-    if (cached)
+    const cached = svgCache.get(name);
+    if (cached !== undefined)
         return cached;
-    const svg = renderToStaticMarkup(createElement(Icon, {
-        size: 24,
-        strokeWidth: 1.9,
-        color: "#000",
-        "aria-hidden": true
-    }));
-    renderedIcons.set(name, svg);
-    return svg;
+    if (!resolveLucideIconName(name)) {
+        svgCache.set(name, null);
+        return null;
+    }
+    try {
+        const svg = await fs.promises.readFile(staticIconPath(name), "utf8");
+        svgCache.set(name, svg);
+        return svg;
+    }
+    catch {
+        svgCache.set(name, null);
+        return null;
+    }
 }