@olares/lares-core 0.15.0

package/files/preview.js

@@ -0,0 +1,305 @@
+import { open, stat } from "node:fs/promises";
+import { basename, extname, relative } from "node:path";
+import { isFilesPath, parseFilesPath } from "../drive/files-path.js";
+import { statFilesFile } from "../drive/ls.js";
+import { HttpError } from "../tools/http.js";
+import {
+  resolveExistingWorkspacePath,
+  resolveWorkspaceRoot,
+  workspaceCandidate,
+} from "../workspace/path.js";
+import { materializeFilesFile } from "./preview-cache.js";
+
+export const MAX_PREVIEW_TEXT_BYTES = 1024 * 1024;
+export const MAX_RAW_BYTES = 200 * 1024 * 1024;
+
+const IMAGE_TYPES = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".bmp", "image/bmp"],
+]);
+const VIDEO_TYPES = new Map([
+  [".mp4", "video/mp4"],
+  [".webm", "video/webm"],
+  [".mov", "video/quicktime"],
+  [".m4v", "video/x-m4v"],
+  [".ogv", "video/ogg"],
+]);
+const AUDIO_TYPES = new Map([
+  [".mp3", "audio/mpeg"],
+  [".wav", "audio/wav"],
+  [".ogg", "audio/ogg"],
+  [".m4a", "audio/mp4"],
+  [".aac", "audio/aac"],
+  [".flac", "audio/flac"],
+]);
+const TEXT_EXTENSIONS = new Set([
+  "",
+  ".txt", ".log", ".json", ".csv", ".tsv", ".yaml", ".yml", ".toml", ".xml",
+  ".html", ".htm", ".css", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+  ".py", ".sh", ".bash", ".zsh", ".env", ".ini", ".cfg", ".conf", ".rs",
+  ".go", ".java", ".kt", ".c", ".h", ".cpp", ".hpp", ".sql", ".r", ".rb",
+  ".php", ".swift", ".vue", ".svelte", ".mdx", ".gitignore", ".dockerignore",
+  ".editorconfig", ".srt", ".vtt", ".ass", ".ssa",
+]);
+
+export function previewQueryFromUrl(reqUrl) {
+  const url = new URL(reqUrl ?? "/", "http://x");
+  const path = url.searchParams.get("path");
+  if (!path) throw new HttpError("path_invalid", 400, "file path is required");
+  return { path, sessionId: url.searchParams.get("sessionId") };
+}
+
+function asPreviewHttpError(error) {
+  if (error instanceof HttpError) return error;
+  const code = error?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  if (code === "file_not_found") return new HttpError("file_not_found", 404, "file was not found");
+  if (code === "path_not_file") return new HttpError("path_not_file", 415, "path is not a regular file");
+  if (code === "path_invalid") return new HttpError("path_invalid", 400, message);
+  return new HttpError("file_preview_failed", 502, message);
+}
+
+export async function resolveFilesPreviewFile(requestedPath, deps = {}) {
+  let source;
+  try {
+    source = parseFilesPath(requestedPath);
+  } catch (error) {
+    throw new HttpError("path_invalid", 400, error instanceof Error ? error.message : String(error));
+  }
+  try {
+    const info = await (deps.stat ?? statFilesFile)(source, deps);
+    return {
+      origin: "files",
+      path: info.path,
+      name: info.name,
+      size: info.size,
+      modifiedAt: info.modifiedAt,
+      ...previewTypeForName(info.name),
+    };
+  } catch (error) {
+    throw asPreviewHttpError(error);
+  }
+}
+
+export async function fileFromPreviewRequest(reqUrl, resolveWorkspace, deps = {}) {
+  const { path, sessionId } = previewQueryFromUrl(reqUrl);
+  if (isFilesPath(path)) return resolveFilesPreviewFile(path, deps);
+  const workspace = await resolveWorkspace(sessionId);
+  return resolveWorkspaceFile(workspace.path, path);
+}
+
+async function ensurePreviewBytes(file, deps = {}) {
+  if (file.absolutePath) return file;
+  if (file.origin !== "files") {
+    throw new HttpError("file_preview_failed", 500, "file has no local path");
+  }
+  try {
+    return await (deps.materialize ?? materializeFilesFile)(file, deps);
+  } catch (error) {
+    throw asPreviewHttpError(error);
+  }
+}
+
+export function previewTypeForName(name) {
+  const extension = extname(name).toLowerCase();
+  if (IMAGE_TYPES.has(extension)) return { kind: "image", mediaType: IMAGE_TYPES.get(extension) };
+  if (VIDEO_TYPES.has(extension)) return { kind: "video", mediaType: VIDEO_TYPES.get(extension) };
+  if (AUDIO_TYPES.has(extension)) return { kind: "audio", mediaType: AUDIO_TYPES.get(extension) };
+  if (extension === ".pdf") return { kind: "pdf", mediaType: "application/pdf" };
+  if (extension === ".md" || extension === ".markdown") {
+    return { kind: "markdown", mediaType: "text/markdown; charset=utf-8" };
+  }
+  if (TEXT_EXTENSIONS.has(extension)) return { kind: "text", mediaType: "text/plain; charset=utf-8" };
+  return { kind: "unsupported", mediaType: "application/octet-stream" };
+}
+
+export async function resolveWorkspaceFile(workspacePath, requestedPath) {
+  if (typeof requestedPath !== "string" || !requestedPath.trim() || requestedPath.includes("\0")) {
+    throw new HttpError("path_invalid", 400, "file path is required");
+  }
+  const root = await resolveWorkspaceRoot(workspacePath);
+  const candidate = workspaceCandidate(root, requestedPath);
+  const absolutePath = await resolveExistingWorkspacePath(root, candidate);
+  const info = await stat(absolutePath).catch(() => {
+    throw new HttpError("file_not_found", 404, "file was not found");
+  });
+  // Distinct from a missing file: a directory is a legitimate open target that
+  // this route simply does not serve, and the caller decides what to do with it.
+  if (!info.isFile()) throw new HttpError("path_not_file", 415, "path is not a regular file");
+  return {
+    absolutePath,
+    path: relative(root, absolutePath),
+    name: basename(absolutePath),
+    size: info.size,
+    modifiedAt: info.mtimeMs,
+    device: info.dev,
+    inode: info.ino,
+    ...previewTypeForName(absolutePath),
+  };
+}
+
+/**
+ * The truncation cut is a byte offset, so it can land inside a multi-byte
+ * character. Dropping that partial tail keeps a truncated preview from being
+ * reported as a non-text file.
+ */
+function trimPartialUtf8(body) {
+  for (let back = 1; back <= 3 && back <= body.length; back += 1) {
+    const byte = body[body.length - back];
+    if ((byte & 0xc0) === 0x80) continue;
+    const width = byte >= 0xf0 ? 4 : byte >= 0xe0 ? 3 : byte >= 0xc0 ? 2 : 1;
+    return width > back ? body.subarray(0, body.length - back) : body;
+  }
+  return body;
+}
+
+export async function buildPreview(file, deps) {
+  const metadata = {
+    path: file.path,
+    name: file.name,
+    kind: file.kind,
+    mediaType: file.mediaType,
+    size: file.size,
+    modifiedAt: file.modifiedAt,
+  };
+  const knownText = ["text", "markdown"].includes(file.kind);
+  if (!knownText && file.kind !== "unsupported") return metadata;
+  const local = await ensurePreviewBytes(file, deps);
+  const handle = await openVerified(local);
+  try {
+    const length = Math.min(local.size, MAX_PREVIEW_TEXT_BYTES + 1);
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, 0);
+    const truncated = bytesRead > MAX_PREVIEW_TEXT_BYTES;
+    const read = buffer.subarray(0, Math.min(bytesRead, MAX_PREVIEW_TEXT_BYTES));
+    const body = truncated ? trimPartialUtf8(read) : read;
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(body);
+    if (!knownText && !looksLikeText(text)) return metadata;
+    return {
+      ...metadata,
+      kind: knownText ? file.kind : "text",
+      mediaType: knownText ? file.mediaType : "text/plain; charset=utf-8",
+      text,
+      truncated: local.size > MAX_PREVIEW_TEXT_BYTES,
+    };
+  } catch (error) {
+    if (error instanceof TypeError) {
+      if (!knownText) return metadata;
+      throw new HttpError("file_not_text", 415, "file is not valid UTF-8 text");
+    }
+    throw error;
+  } finally {
+    await handle.close();
+  }
+}
+
+export async function openVerified(file) {
+  let handle;
+  try {
+    handle = await open(file.absolutePath, "r");
+    const info = await handle.stat();
+    if (
+      info.dev !== file.device
+      || info.ino !== file.inode
+      || info.size !== file.size
+      || info.mtimeMs !== file.modifiedAt
+    ) {
+      throw new HttpError("file_changed", 409, "file changed while it was being opened");
+    }
+    return handle;
+  } catch (error) {
+    await handle?.close().catch(() => {});
+    if (error?.code === "ENOENT") {
+      throw new HttpError("file_not_found", 404, "file was not found");
+    }
+    throw error;
+  }
+}
+
+function looksLikeText(text) {
+  if (text.includes("\0")) return false;
+  let controls = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0);
+    if (code < 32 && char !== "\n" && char !== "\r" && char !== "\t") controls += 1;
+  }
+  return controls <= Math.max(2, text.length / 100);
+}
+
+export function parseRange(value, size) {
+  if (value === undefined) return null;
+  const match = /^bytes=(\d*)-(\d*)$/.exec(String(value).trim());
+  if (!match || (!match[1] && !match[2]) || size <= 0) {
+    throw new HttpError("range_not_satisfiable", 416, "invalid byte range");
+  }
+  let start;
+  let end;
+  if (!match[1]) {
+    const suffix = Number(match[2]);
+    if (!Number.isSafeInteger(suffix) || suffix <= 0) {
+      throw new HttpError("range_not_satisfiable", 416, "invalid byte range");
+    }
+    start = Math.max(0, size - suffix);
+    end = size - 1;
+  } else {
+    start = Number(match[1]);
+    end = match[2] ? Number(match[2]) : size - 1;
+  }
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || start >= size || end < start) {
+    throw new HttpError("range_not_satisfiable", 416, "invalid byte range");
+  }
+  return { start, end: Math.min(end, size - 1) };
+}
+
+async function sendFile(req, res, file, disposition) {
+  const range = parseRange(req.headers.range, file.size);
+  const handle = await openVerified(file);
+  const start = range?.start ?? 0;
+  const end = range?.end ?? Math.max(0, file.size - 1);
+  const headers = {
+    "accept-ranges": "bytes",
+    "cache-control": "private, no-cache",
+    "content-type": file.mediaType,
+    "content-length": String(file.size === 0 ? 0 : end - start + 1),
+    "content-disposition": `${disposition}; filename*=UTF-8''${encodeURIComponent(file.name)}`,
+    "x-content-type-options": "nosniff",
+  };
+  if (range) headers["content-range"] = `bytes ${start}-${end}/${file.size}`;
+  res.writeHead(range ? 206 : 200, headers);
+  if (req.method === "HEAD" || file.size === 0) {
+    await handle.close();
+    res.end();
+    return;
+  }
+  const stream = handle.createReadStream({ start, end, autoClose: true });
+  stream.on("error", (error) => {
+    if (!res.headersSent) res.destroy(error);
+    else res.destroy();
+  });
+  stream.pipe(res);
+}
+
+export async function sendRawFile(req, res, file, deps) {
+  if (!["image", "video", "audio", "pdf"].includes(file.kind)) {
+    throw new HttpError("preview_unsupported", 415, "raw preview is not supported for this file");
+  }
+  // Video and audio are range-streamed, so their total size is not browser
+  // memory pressure. Images and PDFs are consumed as whole documents.
+  if (["image", "pdf"].includes(file.kind) && file.size > MAX_RAW_BYTES) {
+    throw new HttpError("file_too_large", 413, `file exceeds ${MAX_RAW_BYTES} bytes`);
+  }
+  return sendFile(req, res, await ensurePreviewBytes(file, deps), "inline");
+}
+
+/**
+ * Saving a file is not previewing it: the kind and size limits guard what a
+ * media element or iframe will be asked to hold, and neither says anything
+ * about what the user may keep a copy of.
+ */
+export async function sendFileDownload(req, res, file, deps) {
+  return sendFile(req, res, await ensurePreviewBytes(file, deps), "attachment");
+}

package/files/upload-client.js

@@ -0,0 +1,40 @@
+const UPLOAD_TIMEOUT_MS = 120_000;
+export const FILES_UPLOAD_PATH = "/api/lares/files/upload";
+
+function errorCode(payload) {
+  return payload && typeof payload === "object" && payload.error && typeof payload.error.code === "string"
+    ? payload.error.code
+    : "file_upload_failed";
+}
+
+export async function uploadFile(file, sessionId, options = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), UPLOAD_TIMEOUT_MS);
+  const onAbort = () => controller.abort(options.signal?.reason);
+  if (options.signal?.aborted) controller.abort(options.signal.reason);
+  else options.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const response = await fetch(options.url ?? FILES_UPLOAD_PATH, {
+      method: "POST",
+      headers: {
+        "content-type": file.type || "application/octet-stream",
+        "x-lares-file-name": encodeURIComponent(file.name || "file"),
+        "x-lares-session-id": sessionId,
+        "x-lares-upload-request-id": options.requestId ?? crypto.randomUUID(),
+      },
+      body: file,
+      signal: controller.signal,
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) {
+      const error = new Error(errorCode(payload));
+      error.status = response.status;
+      throw error;
+    }
+    if (!payload || typeof payload.path !== "string") throw new Error("file_upload_failed");
+    return payload;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+}

package/files/upload-http.js

@@ -0,0 +1,22 @@
+import { HttpError } from "../tools/http.js";
+import { decodeUploadFilename, sanitizeFilename, UPLOAD_REQUEST_ID } from "./upload.js";
+
+export function parseUploadHeaders(headers) {
+  const sessionId = headers["x-lares-session-id"];
+  const requestId = headers["x-lares-upload-request-id"];
+  if (typeof requestId !== "string" || !UPLOAD_REQUEST_ID.test(requestId)) {
+    throw new HttpError("upload_request_invalid", 400, "valid upload request id is required");
+  }
+  const filename = decodeUploadFilename(headers["x-lares-file-name"]);
+  const mediaType = String(headers["content-type"] || "application/octet-stream").split(";", 1)[0];
+  return { sessionId, requestId, filename, mediaType, name: sanitizeFilename(filename) };
+}
+
+export function uploadSuccessBody(stored, filename, mediaType) {
+  return {
+    path: stored.path,
+    name: sanitizeFilename(filename),
+    size: stored.size,
+    mediaType,
+  };
+}

package/files/upload.js

@@ -0,0 +1,104 @@
+import { createWriteStream, existsSync, openSync, rmSync, statSync } from "node:fs";
+import { rename } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { HttpError } from "../tools/http.js";
+import { ensureWorkspaceDirectory } from "../workspace/path.js";
+import { sanitizeFilename } from "./filename.js";
+import { DEFAULT_MAX_UPLOAD_BYTES } from "./limits.js";
+
+export { DEFAULT_MAX_UPLOAD_BYTES, sanitizeFilename };
+export const UPLOAD_REQUEST_ID = /^[A-Za-z0-9_-]{16,80}$/;
+const UPLOAD_DIRECTORY = [".lares", "uploads"];
+/** More same-named files than any composer batch; past it the name is hostile. */
+const MAX_NAME_ATTEMPTS = 200;
+
+export function decodeUploadFilename(value) {
+  if (typeof value !== "string" || !value) return "file";
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    throw new HttpError("filename_invalid", 400, "invalid file name");
+  }
+}
+
+/**
+ * `report.pdf` → `report-2.pdf`. The number goes before the extension so the
+ * file type survives, and the model reading the mention still sees the name the
+ * user recognizes.
+ */
+export function numberedName(name, attempt) {
+  if (attempt <= 1) return name;
+  const extension = extname(name);
+  return `${name.slice(0, name.length - extension.length)}-${attempt}${extension}`;
+}
+
+/**
+ * Take the first free name for this upload. The exclusive `.part` create is the
+ * claim: two uploads of one name race here rather than over the final path, so
+ * each ends up with a number of its own.
+ */
+function claimName(directory, filename) {
+  const name = sanitizeFilename(filename);
+  for (let attempt = 1; attempt <= MAX_NAME_ATTEMPTS; attempt += 1) {
+    const candidate = numberedName(name, attempt);
+    const absolutePath = join(directory, candidate);
+    if (existsSync(absolutePath)) continue;
+    const temporary = `${absolutePath}.part`;
+    try {
+      const fd = openSync(temporary, "wx", 0o600);
+      return {
+        absolutePath,
+        temporary,
+        fd,
+        relativePath: join(...UPLOAD_DIRECTORY, candidate),
+      };
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+    }
+  }
+  throw new HttpError("file_upload_failed", 409, `no free name for "${name}"`);
+}
+
+function byteLimit(maxBytes) {
+  let total = 0;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      total += chunk.length;
+      if (total > maxBytes) {
+        callback(new HttpError("file_too_large", 413, `file exceeds ${maxBytes} bytes`));
+        return;
+      }
+      callback(null, chunk);
+    },
+  });
+}
+
+/**
+ * Stream one upload into the workspace under the name the user chose.
+ * @returns the workspace-relative path the composer mentions, and the bytes stored.
+ */
+export async function saveUpload(req, workspacePath, filename, maxBytes = DEFAULT_MAX_UPLOAD_BYTES) {
+  const declared = Number(req.headers["content-length"]);
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    throw new HttpError("file_too_large", 413, `file exceeds ${maxBytes} bytes`);
+  }
+
+  const { directory } = await ensureWorkspaceDirectory(workspacePath, UPLOAD_DIRECTORY);
+  const claim = claimName(directory, filename);
+  try {
+    await pipeline(
+      req,
+      byteLimit(maxBytes),
+      createWriteStream(claim.temporary, { fd: claim.fd, autoClose: true }),
+    );
+    const size = statSync(claim.temporary).size;
+    if (size === 0) throw new HttpError("file_empty", 400, "file is empty");
+    await rename(claim.temporary, claim.absolutePath);
+    return { path: claim.relativePath, size };
+  } catch (error) {
+    rmSync(claim.temporary, { force: true });
+    throw error;
+  }
+}

package/i18n/chat-model-switch.js

@@ -0,0 +1,41 @@
+export const ZH = {
+  "reasoning.default": "默认",
+  "reasoning.title": "推理强度",
+  "reasoning.switchAria": "切换推理强度，当前 {label}",
+  "effort.off": "关闭",
+  "effort.minimal": "最低",
+  "effort.low": "低",
+  "effort.medium": "中",
+  "effort.high": "高",
+  "effort.xhigh": "很高",
+  "effort.max": "最高",
+  "model.select": "选择模型",
+  "model.switchAria": "切换模型，当前 {label}",
+  "model.menuAria": "模型",
+  "model.refreshing": "正在刷新模型列表…",
+  "model.opFailed": "模型操作失败：{msg}",
+  "model.loadFailed": "{name} 加载失败：{msg}",
+  "model.empty": "没有可用的模型。",
+  "slot.model": "模型",
+};
+
+export const EN = {
+  "reasoning.default": "Default",
+  "reasoning.title": "Reasoning effort",
+  "reasoning.switchAria": "Switch reasoning effort, current {label}",
+  "effort.off": "Off",
+  "effort.minimal": "Minimal",
+  "effort.low": "Low",
+  "effort.medium": "Medium",
+  "effort.high": "High",
+  "effort.xhigh": "Very high",
+  "effort.max": "Max",
+  "model.select": "Select model",
+  "model.switchAria": "Switch model, current {label}",
+  "model.menuAria": "Model",
+  "model.refreshing": "Refreshing models…",
+  "model.opFailed": "Model action failed: {msg}",
+  "model.loadFailed": "{name} failed to load: {msg}",
+  "model.empty": "No models available.",
+  "slot.model": "Model",
+};

package/i18n/chat-model.js

@@ -0,0 +1,40 @@
+export const ZH = {
+  "settings.nav": "模型配置",
+  "settings.title": "模型",
+  "settings.intro": "模型来自 Olares Router。选中的模型是新会话的默认模型；会话内可随时在输入框上方切换。",
+  "settings.loading": "正在读取模型列表…",
+  "settings.refresh": "刷新",
+  "settings.refreshing": "刷新中…",
+  "settings.router": "Router 控制台",
+  "settings.status.ready": "对话可用 · 默认模型 {model}",
+  "settings.status.notReady": "对话模型尚不可用，请先在 Olares 模型控制台配置对话模型",
+  "settings.empty": "Router 暂时没有可用的对话模型。",
+  "settings.default": "默认",
+  "settings.setDefault": "设为默认",
+  "settings.listAria": "可用模型",
+  "settings.loadFailed": "读取模型列表失败：{msg}",
+  "settings.refreshFailed": "刷新模型列表失败：{msg}",
+  "settings.saveFailed": "设置默认模型失败：{msg}",
+  "settings.providerFailed": "{name} 的模型列表读取失败：{msg}",
+};
+
+export const EN = {
+  "settings.nav": "Model configuration",
+  "settings.title": "Models",
+  "settings.intro":
+    "Models come from Olares Router. The selected one starts every new session; a session can switch above the composer at any time.",
+  "settings.loading": "Loading models…",
+  "settings.refresh": "Refresh",
+  "settings.refreshing": "Refreshing…",
+  "settings.router": "Router console",
+  "settings.status.ready": "Chat ready · default model {model}",
+  "settings.status.notReady": "Chat unavailable; configure a chat model in the Olares Model Console first",
+  "settings.empty": "Router serves no chat model right now.",
+  "settings.default": "Default",
+  "settings.setDefault": "Set as default",
+  "settings.listAria": "Available models",
+  "settings.loadFailed": "Failed to load models: {msg}",
+  "settings.refreshFailed": "Failed to refresh models: {msg}",
+  "settings.saveFailed": "Failed to set the default model: {msg}",
+  "settings.providerFailed": "Failed to list models for {name}: {msg}",
+};

package/i18n/files.js

@@ -0,0 +1,39 @@
+export const ZH = {
+  "button.idle": "添加图片或文件",
+  "button.uploading": "正在上传 {count} 个文件…",
+  "button.blocked": "当前无法添加文件",
+  "upload.blocked": "文件上传完成后才能发送",
+  "upload.failures": "文件上传失败提示",
+  "upload.failed": "{name} 上传失败：{reason}",
+  "upload.retry": "重试",
+  "upload.dismiss": "关闭",
+  "upload.unlinked": "已上传到 {path}，但没能插入输入框",
+  "error.file_too_large": "文件超过 100 MB",
+  "error.file_empty": "不能上传空文件",
+  "error.file_upload_cancelled": "上传已取消",
+  "error.file_input_blocked": "当前无法添加该文件",
+  "error.upload_request_invalid": "上传请求无效",
+  "error.workspace_not_found": "当前会话没有可用工作区",
+  "error.workspace_unavailable": "当前工作区不可用",
+  "error.file_upload_failed": "文件上传失败，请重试",
+};
+
+export const EN = {
+  "button.idle": "Add images or files",
+  "button.uploading": "Uploading {count} file(s)…",
+  "button.blocked": "File input unavailable",
+  "upload.blocked": "Wait for file uploads before sending",
+  "upload.failures": "File upload failures",
+  "upload.failed": "{name} failed to upload: {reason}",
+  "upload.retry": "Retry",
+  "upload.dismiss": "Dismiss",
+  "upload.unlinked": "Uploaded to {path} but could not be inserted into the composer",
+  "error.file_too_large": "File exceeds 100 MB",
+  "error.file_empty": "Empty files cannot be uploaded",
+  "error.file_upload_cancelled": "Upload cancelled",
+  "error.file_input_blocked": "The file cannot be added right now",
+  "error.upload_request_invalid": "Invalid upload request",
+  "error.workspace_not_found": "No workspace is available for this session",
+  "error.workspace_unavailable": "The current workspace is unavailable",
+  "error.file_upload_failed": "File upload failed; please retry",
+};