texlite 0.7.5 → 0.7.6

package/dist/server/git.js

@@ -4,6 +4,7 @@ import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { assertGitAvailable } from "./environment.js";
 import { assertNoSourceSymlinks, sourceRoot, symbolicLinkError } from "./files.js";
+import { httpError } from "./http.js";
 import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
 const MAX_COMMAND_OUTPUT = 8 * 1024 * 1024;
 const MAX_DIFF_OUTPUT = 1024 * 1024;
@@ -75,11 +76,11 @@ export class ProjectGitService {
     async configureToken(project, tokenInput) {
         const token = tokenInput.trim();
         if (token.length < 20 || token.length > 500)
-            throw httpError(400, "GitHub token 格式不正确");
+            throw httpError(400, "GIT_TOKEN_INVALID");
         await this.ensureGitAvailable();
         const account = await this.githubRequest(token, "/user", { method: "GET" });
         if (typeof account.login !== "string" || !account.login)
-            throw httpError(502, "GitHub 没有返回有效的用户信息");
+            throw httpError(502, "GIT_ACCOUNT_INVALID");
         await this.ensureRepository(project);
         const timestamp = new Date().toISOString();
         this.db.prepare(`INSERT INTO project_git_settings
@@ -97,18 +98,18 @@ export class ProjectGitService {
     }
     async createGitHubRepository(project, name, isPrivate) {
         if (!/^[A-Za-z0-9._-]{1,100}$/.test(name))
-            throw httpError(400, "GitHub 仓库名称只能包含字母、数字、点、横线或下划线");
+            throw httpError(400, "GIT_REPOSITORY_NAME_INVALID");
         await this.ensureGitAvailable();
         const settings = this.requireTokenSettings(project.id);
         if (settings.remote_url)
-            throw httpError(409, "该项目已经配置远程仓库");
+            throw httpError(409, "GIT_REMOTE_ALREADY_CONFIGURED");
         const token = decryptToken(this.config, settings.token_ciphertext);
         const repository = await this.githubRequest(token, "/user/repos", {
             method: "POST",
             body: JSON.stringify({ name, private: isPrivate, auto_init: false, description: `Backup of ${project.name}` })
         });
         if (typeof repository.clone_url !== "string" || typeof repository.html_url !== "string") {
-            throw httpError(502, "GitHub 没有返回有效的仓库地址");
+            throw httpError(502, "GIT_REPOSITORY_RESPONSE_INVALID");
         }
         await this.ensureRepository(project);
         const root = sourceRoot(this.config, project.id);
@@ -127,16 +128,16 @@ export class ProjectGitService {
     async commit(project, owner, messageInput) {
         const message = messageInput.trim();
         if (!message || message.length > 300)
-            throw httpError(400, "提交说明不能为空且不能超过 300 个字符");
+            throw httpError(400, "GIT_COMMIT_MESSAGE_INVALID");
         const root = this.requireRepository(project.id);
         assertNoSourceSymlinks(this.config, project.id);
         const branch = await this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"], [1]);
         if (branch.code !== 0)
-            throw httpError(409, "当前处于 detached HEAD，请先返回默认分支再提交");
+            throw httpError(409, "GIT_DETACHED_HEAD");
         await this.git(root, ["add", "--all"]);
         const staged = await this.git(root, ["diff", "--cached", "--quiet"], [1]);
         if (staged.code === 0)
-            throw httpError(409, "当前没有可以提交的修改");
+            throw httpError(409, "GIT_NO_CHANGES");
         await this.git(root, [
             "-c", `user.name=${owner.username}`,
             "-c", `user.email=${owner.username}@texlite.com`,
@@ -150,18 +151,18 @@ export class ProjectGitService {
     async push(project) {
         const settings = this.requireTokenSettings(project.id);
         if (!settings.remote_url)
-            throw httpError(409, "请先创建 GitHub 仓库");
+            throw httpError(409, "GIT_REMOTE_NOT_CONFIGURED");
         const root = this.requireRepository(project.id);
         assertNoSourceSymlinks(this.config, project.id);
         const head = await this.git(root, ["rev-parse", "--verify", "HEAD"], [128]);
         if (head.code !== 0)
-            throw httpError(409, "请先提交项目修改");
+            throw httpError(409, "GIT_NO_COMMIT");
         const branchResult = await this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"], [1]);
         if (branchResult.code !== 0)
-            throw httpError(409, "当前处于 detached HEAD，请先返回默认分支再推送");
+            throw httpError(409, "GIT_DETACHED_HEAD");
         const branch = branchResult.stdout.trim();
         if (!/^[A-Za-z0-9._/-]+$/.test(branch))
-            throw httpError(400, "本地分支名称无效");
+            throw httpError(400, "GIT_BRANCH_INVALID");
         const token = decryptToken(this.config, settings.token_ciphertext);
         await this.git(root, ["push", "--set-upstream", "origin", `HEAD:refs/heads/${branch}`], [], this.authEnvironment(token));
         return this.status(project);
@@ -221,7 +222,7 @@ export class ProjectGitService {
         const root = this.requireRepository(project.id);
         const head = await this.git(root, ["rev-parse", "--verify", "HEAD"], [128]);
         if (head.code !== 0)
-            throw httpError(409, "该项目尚无可恢复的提交");
+            throw httpError(409, "GIT_NO_COMMIT");
         await this.assertRevisionHasNoSymlinks(root, head.stdout.trim());
         await this.git(root, ["restore", "--source=HEAD", "--staged", "--worktree", "--", "."]);
         assertNoSourceSymlinks(this.config, project.id);
@@ -260,7 +261,7 @@ export class ProjectGitService {
                 throw error;
         }
         if (!gitStat)
-            throw httpError(409, "该项目尚未初始化 Git");
+            throw httpError(409, "GIT_REPOSITORY_NOT_INITIALIZED");
         if (gitStat.isSymbolicLink() || !gitStat.isDirectory())
             throw symbolicLinkError(".git");
         return root;
@@ -271,13 +272,13 @@ export class ProjectGitService {
     requireTokenSettings(projectId) {
         const settings = this.settings(projectId);
         if (!settings?.token_ciphertext)
-            throw httpError(409, "请先配置 GitHub token");
+            throw httpError(409, "GIT_TOKEN_NOT_CONFIGURED");
         return settings;
     }
     async verifyCommit(root, revision) {
         const result = await this.git(root, ["rev-parse", "--verify", `${revision}^{commit}`], [128]);
         if (result.code !== 0)
-            throw httpError(404, "Git 版本不存在");
+            throw httpError(404, "GIT_REVISION_NOT_FOUND");
         return result.stdout.trim();
     }
     async assertRevisionHasNoSymlinks(root, revision) {
@@ -301,16 +302,14 @@ export class ProjectGitService {
                     ...(init.body ? { "Content-Type": "application/json" } : {})
                 }
             });
-            const body = await response.json().catch(() => ({}));
             if (!response.ok) {
-                const message = typeof body.message === "string" ? body.message : `HTTP ${response.status}`;
-                throw httpError(response.status === 401 || response.status === 403 ? 400 : 502, `GitHub 请求失败：${message}`);
+                throw httpError(response.status === 401 || response.status === 403 ? 400 : 502, response.status === 401 || response.status === 403 ? "GIT_TOKEN_REJECTED" : "GIT_OPERATION_FAILED");
             }
-            return body;
+            return await response.json();
         }
         catch (error) {
             if (error instanceof Error && error.name === "AbortError")
-                throw httpError(504, "GitHub 请求超时");
+                throw httpError(504, "GIT_TIMEOUT");
             throw error;
         }
         finally {
@@ -368,17 +367,16 @@ export class ProjectGitService {
             };
             child.stdout.on("data", collect(stdout));
             child.stderr.on("data", collect(stderr));
-            child.once("error", (error) => { clearTimeout(timer); reject(httpError(500, `无法运行 Git：${error.message}`)); });
+            child.once("error", () => { clearTimeout(timer); reject(httpError(500, "GIT_OPERATION_FAILED")); });
             child.once("close", (code) => {
                 clearTimeout(timer);
                 const result = { stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), code: code ?? -1 };
                 if (timedOut)
-                    return reject(httpError(504, "Git 操作超时"));
+                    return reject(httpError(504, "GIT_TIMEOUT"));
                 if (size > MAX_COMMAND_OUTPUT)
-                    return reject(httpError(413, "Git 输出过大"));
+                    return reject(httpError(413, "GIT_OUTPUT_TOO_LARGE"));
                 if (result.code !== 0 && !allowedCodes.includes(result.code)) {
-                    const detail = (result.stderr || result.stdout).trim().slice(0, 2000) || `exit ${result.code}`;
-                    return reject(httpError(400, `Git 操作失败：${detail}`));
+                    return reject(httpError(400, "GIT_COMMAND_FAILED"));
                 }
                 resolve(result);
             });
@@ -392,7 +390,7 @@ function parseCommit(line) {
 function validateRevision(value) {
     const revision = value.trim();
     if (!/^[a-f0-9]{7,40}$/i.test(revision))
-        throw httpError(400, "Git 版本格式不正确");
+        throw httpError(400, "GIT_REVISION_INVALID");
     return revision;
 }
 function tokenKey(config) {
@@ -409,7 +407,7 @@ function tokenKey(config) {
     }
     const key = fs.readFileSync(target);
     if (key.length !== 32)
-        throw httpError(500, "Git token 加密密钥无效");
+        throw httpError(500, "GIT_OPERATION_FAILED");
     return key;
 }
 function encryptToken(config, token) {
@@ -421,22 +419,13 @@ function encryptToken(config, token) {
 function decryptToken(config, encoded) {
     const [version, ivText, tagText, encryptedText] = encoded.split(".");
     if (version !== "v1" || !ivText || !tagText || !encryptedText)
-        throw httpError(500, "GitHub token 无法解密");
+        throw httpError(500, "GIT_OPERATION_FAILED");
     try {
         const decipher = createDecipheriv("aes-256-gcm", tokenKey(config), Buffer.from(ivText, "base64url"));
         decipher.setAuthTag(Buffer.from(tagText, "base64url"));
         return Buffer.concat([decipher.update(Buffer.from(encryptedText, "base64url")), decipher.final()]).toString("utf8");
     }
     catch {
-        throw httpError(500, "GitHub token 无法解密");
+        throw httpError(500, "GIT_OPERATION_FAILED");
     }
 }
-function httpError(statusCode, message) {
-    const code = statusCode === 400 ? "GIT_INVALID"
-        : statusCode === 404 ? "GIT_REVISION_NOT_FOUND"
-            : statusCode === 409 ? "GIT_CONFLICT"
-                : statusCode === 413 ? "GIT_OUTPUT_TOO_LARGE"
-                    : statusCode === 504 ? "GIT_TIMEOUT"
-                        : statusCode >= 500 ? "GIT_OPERATION_FAILED" : "REQUEST_INVALID";
-    return Object.assign(new Error(message), { statusCode, code });
-}

package/dist/server/harper.js

@@ -0,0 +1,144 @@
+import { Worker } from "node:worker_threads";
+const setupTimeoutMs = 45_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); });
+    });
+}
+/**
+ * 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.
+ */
+export class HarperService {
+    useWorker = import.meta.url.endsWith(".js");
+    linter = null;
+    setupPromise = null;
+    worker = null;
+    nextRequestId = 1;
+    pending = new Map();
+    queue = Promise.resolve();
+    async preload() {
+        await this.ensureRuntime();
+    }
+    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;
+            }
+        });
+        this.queue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async dispose() {
+        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."));
+    }
+    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.")
+            .catch((error) => {
+            this.stopFailedWorker(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        })
+            .finally(() => { this.setupPromise = null; });
+        return this.setupPromise;
+    }
+    async startInProcess() {
+        const { createHarperLinter } = await import("./harperRuntime.js");
+        this.linter = await createHarperLinter();
+    }
+    startWorker() {
+        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))
+                    return;
+                worker.off("message", onInitialMessage);
+                worker.off("error", rejectStart);
+                if (message.type === "ready")
+                    resolve();
+                else
+                    reject(new Error(message.message));
+            };
+            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)
+                    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 });
+        });
+    }
+    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/harperRuntime.js

@@ -0,0 +1,38 @@
+import { LocalLinter } from "harper.js";
+import { binary } from "harper.js/binary";
+function suggestionText(suggestion) {
+    return suggestion.get_replacement_text();
+}
+export async function createHarperLinter() {
+    const linter = new LocalLinter({ binary });
+    await linter.setup();
+    return linter;
+}
+export async function collectHarperLints(linter, source) {
+    const lints = await linter.lint(source, { language: "plaintext", dedup: true, isolateEnglish: false });
+    try {
+        return lints.map((lint) => {
+            const span = lint.span();
+            const suggestions = lint.suggestions();
+            try {
+                return {
+                    start: span.start,
+                    end: span.end,
+                    problem: lint.get_problem_text(),
+                    kind: lint.lint_kind(),
+                    message: lint.message(),
+                    suggestions: suggestions.map(suggestionText)
+                };
+            }
+            finally {
+                span.free();
+                for (const suggestion of suggestions)
+                    suggestion.free();
+            }
+        });
+    }
+    finally {
+        for (const lint of lints)
+            lint.free();
+    }
+}

package/dist/server/harperWorker.js

@@ -0,0 +1,15 @@
+import { parentPort } from "node:worker_threads";
+import { collectHarperLints, createHarperLinter } from "./harperRuntime.js";
+if (!parentPort)
+    throw new Error("Harper worker requires a parent port.");
+const port = parentPort;
+try {
+    const linter = await createHarperLinter();
+    port.on("message", (request) => {
+        void collectHarperLints(linter, request.source).then((lints) => port.postMessage({ id: request.id, ok: true, lints }), (error) => port.postMessage({ id: request.id, ok: false, message: error instanceof Error ? error.message : String(error) }));
+    });
+    port.postMessage({ type: "ready" });
+}
+catch (error) {
+    port.postMessage({ type: "load-error", message: error instanceof Error ? error.message : String(error) });
+}

package/dist/server/history.js

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { assertNoSourceSymlinks, listProjectFiles, outputRoot, projectRoot, resolveSourcePath, safeRelativePath, sourceRoot } from "./files.js";
+import { httpError } from "./http.js";
+import { MAX_TEXT_PREVIEW_BYTES } from "./limits.js";
 const AUTOSAVE_COALESCE_MS = 2 * 60_000;
 export class ProjectHistoryService {
     config;
@@ -141,11 +143,11 @@ export class ProjectHistoryService {
             return;
         const manifest = this.manifest(projectId, versionId);
         if (!manifest) {
-            throw Object.assign(new Error("历史版本不存在"), { code: "HISTORY_VERSION_NOT_FOUND", statusCode: 404 });
+            throw httpError(404, "HISTORY_VERSION_NOT_FOUND");
         }
         const filePath = safeRelativePath(filePathInput);
         if (!manifest.files[filePath]) {
-            throw Object.assign(new Error("该历史版本中不存在此文件"), { code: "HISTORY_FILE_NOT_FOUND", statusCode: 404 });
+            throw httpError(404, "HISTORY_FILE_NOT_FOUND");
         }
         this.assertRestoreTargetIsFile(projectId, filePath);
     }
@@ -157,19 +159,19 @@ export class ProjectHistoryService {
     readTextFile(projectId, versionId, filePathInput) {
         const filePath = safeRelativePath(filePathInput);
         const entry = this.manifest(projectId, versionId)?.files[filePath];
-        if (!entry || entry.size > 2 * 1024 * 1024)
+        if (!entry || entry.size > MAX_TEXT_PREVIEW_BYTES)
             return null;
         return fs.readFileSync(this.objectPath(projectId, entry.digest), "utf8");
     }
     restore(projectId, versionId, filePathInput) {
         const manifest = this.manifest(projectId, versionId);
         if (!manifest)
-            throw Object.assign(new Error("历史版本不存在"), { code: "HISTORY_VERSION_NOT_FOUND", statusCode: 404 });
+            throw httpError(404, "HISTORY_VERSION_NOT_FOUND");
         if (filePathInput) {
             const filePath = safeRelativePath(filePathInput);
             const entry = manifest.files[filePath];
             if (!entry)
-                throw Object.assign(new Error("该历史版本中不存在此文件"), { code: "HISTORY_FILE_NOT_FOUND", statusCode: 404 });
+                throw httpError(404, "HISTORY_FILE_NOT_FOUND");
             this.assertRestoreTargetIsFile(projectId, filePath);
             const target = resolveSourcePath(this.config, projectId, filePath);
             fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
@@ -193,7 +195,7 @@ export class ProjectHistoryService {
         const target = resolveSourcePath(this.config, projectId, filePath);
         const targetStat = fs.existsSync(target) ? fs.lstatSync(target) : null;
         if (targetStat && !targetStat.isFile()) {
-            throw Object.assign(new Error("历史文件恢复目标不是普通文件"), { code: "HISTORY_TARGET_CONFLICT", statusCode: 409 });
+            throw httpError(409, "HISTORY_TARGET_CONFLICT");
         }
     }
     latestRow(projectId) {
@@ -203,7 +205,7 @@ export class ProjectHistoryService {
     project(projectId) {
         const project = this.db.prepare("SELECT * FROM projects WHERE id = ?").get(projectId);
         if (!project)
-            throw new Error("项目不存在");
+            throw httpError(404, "PROJECT_NOT_FOUND");
         return project;
     }
     emptyManifest(project) {
@@ -267,7 +269,7 @@ export class ProjectHistoryService {
     }
     objectPath(projectId, digest) {
         if (!/^[a-f0-9]{64}$/.test(digest))
-            throw new Error("历史对象摘要无效");
+            throw new Error("Invalid history object digest");
         return path.join(outputRoot(this.config, projectId), ".texlite", "history", "objects", digest.slice(0, 2), digest);
     }
     pruneVersions(projectId) {
@@ -442,7 +444,7 @@ function cloneManifest(manifest) {
 function parseManifest(value) {
     const parsed = JSON.parse(value);
     if (parsed.version !== 1 || !parsed.files || !parsed.settings)
-        throw new Error("历史版本清单损坏");
+        throw new Error("History manifest is invalid");
     return parsed;
 }
 function parseStringArray(value) {

package/dist/server/http.js

@@ -1,8 +1,28 @@
-export class ValidationError extends Error {
-    statusCode = 400;
-    code = "REQUEST_INVALID";
-    constructor(message) {
-        super(message);
+import { serverErrorMessage, serverLocale } from "./i18n.js";
+export class HttpError extends Error {
+    statusCode;
+    code;
+    details;
+    constructor(statusCode, code, details = {}) {
+        // Keep a useful, locale-neutral message for internal callers and logs.
+        // HTTP responses are still rendered using the request's actual locale.
+        super(serverErrorMessage("en", code, details));
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = details;
+        this.name = "HttpError";
+    }
+}
+/**
+ * Create a user-correctable error without putting a locale-specific string in
+ * service or route code. `apiError` resolves the code using the request locale.
+ */
+export function httpError(statusCode, code, details = {}) {
+    return new HttpError(statusCode, code, details);
+}
+export class ValidationError extends HttpError {
+    constructor(code = "REQUEST_INVALID", details = {}) {
+        super(400, code, details);
         this.name = "ValidationError";
     }
 }
@@ -11,21 +31,21 @@ export class ValidationError extends Error {
  * replace or remove source files must stop at this boundary instead of
  * continuing with a stale filesystem snapshot.
  */
-export class SourceFlushError extends Error {
-    statusCode = 409;
-    code = "SOURCE_FLUSH_FAILED";
+export class SourceFlushError extends HttpError {
     failedPaths;
     constructor(failedPaths = []) {
         const paths = [...new Set(failedPaths)].slice(0, 100);
-        super(paths.length
-            ? `部分源码未能保存至磁盘，无法继续项目操作：${paths.join(", ")}`
-            : "部分源码未能保存至磁盘，无法继续项目操作");
+        super(409, "SOURCE_FLUSH_FAILED", { failedPaths: paths });
         this.name = "SourceFlushError";
         this.failedPaths = paths;
     }
 }
-export function apiError(reply, status, code, message, details = {}) {
-    return reply.code(status).send({ code, error: message, ...details });
+export function apiError(reply, status, code, details = {}) {
+    return reply.code(status).send({
+        code,
+        error: serverErrorMessage(serverLocale(reply.request?.headers), code, details),
+        ...details
+    });
 }
 export function contentDisposition(filename, mode) {
     const fallback = filename.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_");