@rigel-cms/rigel 1.0.0 → 1.2.0

package/src/manifest/menu.ts

@@ -1,3 +1,5 @@
+import { systemMessage, type Translator } from "../editor/i18n/format";
+
 export interface MenuItem {
   id: string;
   label: string;
@@ -14,31 +16,31 @@ export interface MenuDocument {
 
 export const MENU_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
-export function validateMenu(value: unknown, maxDepth: number): MenuDocument {
+export function validateMenu(value: unknown, maxDepth: number, message: Translator = systemMessage): MenuDocument {
   if (!Number.isInteger(maxDepth) || maxDepth < 1 || maxDepth > 10)
-    throw new Error("Menu maxDepth must be an integer from 1 to 10");
+    throw new Error(message("validation.menu.maxDepth"));
   const object = (v: unknown): v is Record<string, unknown> =>
     v !== null && typeof v === "object" && !Array.isArray(v);
   const text = (v: unknown): v is string => typeof v === "string" && v.trim().length > 0;
   if (!object(value) || typeof value.slug !== "string" || !MENU_SLUG.test(value.slug) || !text(value.title) || !Array.isArray(value.items))
-    throw new Error("Menu requires a lowercase alphanumeric-hyphen slug, title, and items array");
+    throw new Error(message("validation.menu.required"));
   const ids = new Set<string>();
   function items(values: unknown[], depth: number): MenuItem[] {
     return values.map((item) => {
-      if (depth > maxDepth) throw new Error(`Menu exceeds maximum depth ${maxDepth}`);
+      if (depth > maxDepth) throw new Error(message("validation.menu.depth", { maxDepth }));
       if (!object(item) || !text(item.id) || !text(item.label) || !text(item.url) || !Array.isArray(item.children))
-        throw new Error("Menu items require nonempty id, label, url, and children array");
-      if (ids.has(item.id)) throw new Error(`Duplicate menu item id: ${item.id}`);
+        throw new Error(message("validation.menu.itemRequired"));
+      if (ids.has(item.id)) throw new Error(message("validation.menu.duplicateId", { id: item.id }));
       ids.add(item.id);
-      if (item.newTab !== undefined && typeof item.newTab !== "boolean") throw new Error("Menu item newTab must be a boolean");
+      if (item.newTab !== undefined && typeof item.newTab !== "boolean") throw new Error(message("validation.menu.newTab"));
       const url = item.url;
       if (url !== url.trim() || /[\u0000-\u0020\u007f\\]/.test(url) || url.startsWith("//"))
-        throw new Error("Unsafe menu URL");
+        throw new Error(message("validation.menu.unsafeUrl"));
       let parsed: URL;
       try { parsed = new URL(url, "https://rigel.invalid/"); }
-      catch { throw new Error("Invalid menu URL"); }
+      catch { throw new Error(message("validation.menu.invalidUrl")); }
       if (!["http:", "https:", "mailto:", "tel:"].includes(parsed.protocol))
-        throw new Error("Unsafe menu URL protocol");
+        throw new Error(message("validation.menu.unsafeProtocol"));
       return { id: item.id, label: item.label, url, ...(item.newTab === undefined ? {} : { newTab: item.newTab }), children: items(item.children, depth + 1) };
     });
   }

package/src/manifest/navigation.ts

@@ -1,4 +1,5 @@
 import type { Manifest } from "./types";
+import { systemMessage, type Translator } from "../editor/i18n/format";
 
 export type Selection =
   | { kind: "media" }
@@ -27,24 +28,24 @@ export function navigationKey(target: Selection): string {
   return JSON.stringify([target.kind, "category" in target ? target.category : null, "name" in target ? target.name : null, "slug" in target ? target.slug : null, "type" in target ? target.type : null, "id" in target ? target.id : null, "collection" in target ? target.collection : null]);
 }
 
-export function buildSidebar(manifest: Manifest): SidebarNode[] {
+export function buildSidebar(manifest: Manifest, message: Translator = systemMessage): SidebarNode[] {
   const link = (target: SidebarTarget, label: string): SidebarLink => ({ kind: "link", target, label });
   const types = manifest.schema?.documents ?? [];
   const pageTypes = types.filter(type => !type.shared);
   const pages = manifest.pages.filter(page => !page.shared);
   const categories = [...new Set(pages.map(page => page.category).filter((category): category is string => !!category))].sort();
   const defaults: SidebarNode[] = [
-    { kind: "heading", label: "Website" },
-    link({ kind: "pages" }, "Pages"),
+    { kind: "heading", label: message("system.sidebar.website") },
+    link({ kind: "pages" }, message("system.sidebar.pages")),
     ...(manifest.collections ?? []).map(collection => link({ kind: "collection", name: collection.name }, collection.label)),
     ...categories.map(category => link({ kind: "pages", category }, category)),
     ...pageTypes.slice(1).map(type => link({ kind: "documents", type: type.name }, type.title)),
-    { kind: "heading", label: "Shared content" },
+    { kind: "heading", label: message("system.sidebar.shared") },
     ...types.filter(type => type.shared && !type.singleton).map(type => link({ kind: "documents", type: type.name }, type.title)),
     ...manifest.pages.filter(page => page.shared).map(page => link({ kind: "page", slug: page.slug }, page.label)),
-    ...(manifest.menus ? [link({ kind: "menus" }, "Menus")] : []),
-    { kind: "heading", label: "Assets" },
-    link({ kind: "media" }, "Media"),
+    ...(manifest.menus ? [link({ kind: "menus" }, message("system.sidebar.menus"))] : []),
+    { kind: "heading", label: message("system.sidebar.assets") },
+    link({ kind: "media" }, message("system.sidebar.media")),
     ...(types.some(type => type.shared && type.singleton) ? [{ kind: "separator" } as SidebarNode] : []),
     ...types.filter(type => type.shared && type.singleton).map(type => {
       const doc = manifest.documents?.find(doc => doc.type === type.name);
@@ -53,6 +54,10 @@ export function buildSidebar(manifest: Manifest): SidebarNode[] {
   ];
   if (!manifest.sidebar) return defaults;
   const available = new Map(defaults.filter((node): node is SidebarLink => node.kind === "link").map(node => [navigationKey(node.target), node]));
+  for (const type of types) {
+    const target: SidebarTarget = { kind: "documents", type: type.name };
+    available.set(navigationKey(target), link(target, type.title));
+  }
   for (const page of manifest.pages) available.set(navigationKey({ kind: "page", slug: page.slug }), link({ kind: "page", slug: page.slug }, page.label));
   for (const doc of manifest.documents ?? []) {
     const target: SidebarTarget = { kind: "document", type: doc.type, id: doc.id };
@@ -70,7 +75,7 @@ export function buildSidebar(manifest: Manifest): SidebarNode[] {
     nodes.push({ ...item, label: entry.label ?? item.label, ...(entry.icon ? { icon: entry.icon } : {}) });
   }
   const remaining = defaults.filter((node): node is SidebarLink => node.kind === "link" && !used.has(navigationKey(node.target)));
-  if (remaining.length) nodes.push({ kind: "heading", label: "More content" }, ...remaining);
+  if (remaining.length) nodes.push({ kind: "heading", label: message("system.sidebar.more") }, ...remaining);
   return nodes;
 }
 

package/src/manifest/references.ts

@@ -1,5 +1,6 @@
 import type { CollectionField } from "./types";
 import type { ContentDocument } from "../schema/types";
+import { systemMessage, type Translator } from "../editor/i18n/format";
 
 export interface ReferenceOption {
   value: string;
@@ -19,21 +20,21 @@ export function referenceOptions(field: CollectionField, documents: ContentDocum
   }));
 }
 
-export function referenceLabel(value: unknown, options: ReferenceOption[]): string {
-  return (Array.isArray(value) ? value : [value]).filter(Boolean).map(id => options.find(option => option.value === id)?.label ?? `Unavailable (${String(id)})`).join(", ");
+export function referenceLabel(value: unknown, options: ReferenceOption[], message: Translator = systemMessage): string {
+  return (Array.isArray(value) ? value : [value]).filter(Boolean).map(id => options.find(option => option.value === id)?.label ?? message("system.reference.unavailable", { id: String(id) })).join(", ");
 }
 
-export function collectionPreviewValues(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[]): Record<string, unknown> {
-  return { ...values, ...Object.fromEntries(fields.filter(field => field.type === "reference").map(field => [field.key, referenceLabel(values[field.key], referenceOptions(field, documents))])) };
+export function collectionPreviewValues(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[], message: Translator = systemMessage): Record<string, unknown> {
+  return { ...values, ...Object.fromEntries(fields.filter(field => field.type === "reference").map(field => [field.key, referenceLabel(values[field.key], referenceOptions(field, documents), message)])) };
 }
 
-export function validateCollectionReferences(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[]): void {
+export function validateCollectionReferences(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[], message: Translator = systemMessage): void {
   for (const field of fields.filter(field => field.type === "reference")) {
     const value = values[field.key];
     if (value === undefined) continue;
-    if (field.multiple ? !Array.isArray(value) : typeof value !== "string") throw new Error(`${field.label}: expected ${field.multiple ? "an array of references" : "one reference"}`);
+    if (field.multiple ? !Array.isArray(value) : typeof value !== "string") throw new Error(message(field.multiple ? "system.reference.expectedMany" : "system.reference.expectedOne", { label: field.label }));
     const selected = field.multiple ? value as unknown[] : value === "" ? [] : [value];
     const options = referenceOptions(field, documents);
-    if (new Set(selected).size !== selected.length || selected.some(id => typeof id !== "string" || !options.some(option => option.value === id))) throw new Error(`${field.label}: select existing entries only`);
+    if (new Set(selected).size !== selected.length || selected.some(id => typeof id !== "string" || !options.some(option => option.value === id))) throw new Error(message("system.reference.existingOnly", { label: field.label }));
   }
 }

package/src/manifest/seo.ts

@@ -1,9 +1,10 @@
 import type { CollectionField } from "./types";
+import { systemMessage } from "../editor/i18n/format";
 
 export const SEO_FIELDS = [
-  { key: "metaTitle", label: "SEO title", type: "string" },
-  { key: "description", label: "SEO description", type: "text" },
-  { key: "ogImage", label: "Social image", type: "image" },
+  { key: "metaTitle", label: systemMessage("defaults.seoTitle"), labelKey: "defaults.seoTitle", type: "string" },
+  { key: "description", label: systemMessage("defaults.seoDescription"), labelKey: "defaults.seoDescription", type: "text" },
+  { key: "ogImage", label: systemMessage("defaults.socialImage"), labelKey: "defaults.socialImage", type: "image" },
 ] satisfies CollectionField[];
 
 export function isSeoField(key: string): boolean {

package/src/manifest/types.ts

@@ -15,6 +15,7 @@ export interface CopyGroup {
 
 export interface CopyPage {
   slug: string;
+  locale?: string;
   label: string;
   shared?: boolean;
   category?: string;
@@ -36,6 +37,7 @@ export interface GitHubBackendConfig {
 }
 
 export interface Manifest {
+  contentLocales?: import("../config").ContentLocalesConfig;
   backend?: "github";
   github?: GitHubBackendConfig;
   sidebar?: import("./navigation").SidebarEntry[];
@@ -50,6 +52,7 @@ export interface Manifest {
 export interface CollectionField {
   key: string;
   label: string;
+  labelKey?: string;
   type: "string" | "text" | "boolean" | "date" | "tags" | "markdown" | "image" | "reference";
   to?: string;
   multiple?: boolean;
@@ -65,6 +68,7 @@ export interface CollectionPost {
 
 export interface ManifestCollection {
   name: string;
+  locale?: string;
   label: string;
   listTitle?: string;
   fields: CollectionField[];

package/src/preview.ts

@@ -4,6 +4,7 @@ import { pageRoute } from "./schema/paths";
 import { slugify } from "./slugs";
 import { renderArticle } from "./article-render";
 import { createEmbedPreview } from "./editor/lib/embed-preview";
+import { mountExtensionPreviews } from "./editor/lib/extension-preview";
 import { safePreviewUrl, previewBaseUrl, previewRoute } from "./preview-urls";
 export { safePreviewUrl } from "./preview-urls";
 
@@ -75,6 +76,14 @@ export function anchorValue(values: unknown, path: string): { found: boolean; va
 
 const markdown = new MarkdownIt({ html: false, linkify: false });
 const rendered = new WeakMap<Element, string>();
+const extensionPreviews = new WeakMap<Document, Map<Element, () => void>>();
+
+export function cleanupPreview(doc: Document) {
+  const previews = extensionPreviews.get(doc);
+  if (!previews) return;
+  for (const [element, cleanup] of previews) { cleanup(); rendered.delete(element); }
+  previews.clear();
+}
 
 export interface PatchDocuments {
   editingBody?: Element | null;
@@ -91,6 +100,14 @@ function rebindTree(root: Element | DocumentFragment, update: (element: Element)
 }
 
 export function patchPreview(doc: Document, values: Record<string, unknown>, body: "" | import("./article-body").ArticleBody, options: PatchDocuments = {}) {
+  if (!doc.documentElement) return;
+  let previews = extensionPreviews.get(doc);
+  if (!previews) {
+    previews = new Map();
+    extensionPreviews.set(doc, previews);
+    doc.defaultView?.addEventListener("pagehide", () => cleanupPreview(doc), { once: true });
+  }
+  for (const [element, cleanup] of previews) if (!element.isConnected) { cleanup(); previews.delete(element); rendered.delete(element); }
   const sourceFor = (element: Element): Record<string, unknown> | undefined => {
     const id = element.getAttribute("data-rigel-doc");
     if (id === "") return {};
@@ -156,6 +173,19 @@ export function patchPreview(doc: Document, values: Record<string, unknown>, bod
     const result = get(element, element.getAttribute("data-rigel-if")!);
     if (result.found) element.hidden = !result.value;
   }
+  for (const el of doc.querySelectorAll<HTMLElement>("[data-rigel-tags]")) {
+    if (el.tagName !== "UL" && el.tagName !== "OL") continue;
+    const result = get(el, el.dataset.rigelTags!);
+    if (!result.found) continue;
+    const source = typeof result.value === "string" ? result.value : "";
+    if (rendered.get(el) === source) continue;
+    el.replaceChildren(...source.split(",").map(tag => tag.trim()).filter(Boolean).map(tag => {
+      const item = doc.createElement("li");
+      item.textContent = tag;
+      return item;
+    }));
+    rendered.set(el, source);
+  }
   for (const el of doc.querySelectorAll<HTMLElement>("[data-rigel-text]")) {
     const result = get(el, el.dataset.rigelText!);
     if (!result.found) continue;
@@ -169,11 +199,11 @@ export function patchPreview(doc: Document, values: Record<string, unknown>, bod
     const blocks = el.dataset.rigelRichtext === "$body";
     const source = blocks ? JSON.stringify(result.value) : typeof result.value === "string" ? result.value : "";
     if (rendered.get(el) === source) continue;
-    rendered.set(el, source);
     const fragment = DOMPurify.sanitize(blocks ? (result.value ? renderArticle(result.value as import("./article-body").ArticleBody, { preview: true }) : "") : markdown.render(source), {
       RETURN_DOM_FRAGMENT: true,
       ALLOWED_TAGS: ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "li", "blockquote", "aside", "figure", "figcaption", "pre", "code", "strong", "em", "s", "u", "mark", "sub", "sup", "a", "img", "br", "hr", "table", "thead", "tbody", "tr", "th", "td", ...(blocks ? ["video"] : [])],
-      ALLOWED_ATTR: ["href", "src", "alt", "title", "start", "scope", ...(blocks ? ["controls", "muted", "preload", "playsinline", "poster", "class"] : [])],
+      ALLOW_DATA_ATTR: false,
+      ALLOWED_ATTR: ["href", "src", "alt", "title", "start", "scope", ...(blocks ? ["controls", "muted", "preload", "playsinline", "poster", "class", "data-rigel-embed", "data-rigel-video-id", "data-rigel-video-title", "data-rigel-extension", "data-rigel-extension-data"] : [])],
     });
     if (blocks) for (const marker of fragment.querySelectorAll<HTMLElement>("[data-rigel-embed]")) {
       marker.replaceWith(createEmbedPreview({ provider: marker.dataset.rigelEmbed, id: marker.dataset.rigelVideoId, title: marker.dataset.rigelVideoTitle }, doc));
@@ -181,7 +211,11 @@ export function patchPreview(doc: Document, values: Record<string, unknown>, bod
     for (const link of fragment.querySelectorAll("[href], [src]")) {
       for (const attr of ["href", "src"]) if (link.hasAttribute(attr) && !safePreviewUrl(link.getAttribute(attr)!, attr === "src")) link.removeAttribute(attr);
     }
+    previews.get(el)?.();
+    previews.delete(el);
     el.replaceChildren(fragment);
+    if (blocks) previews.set(el, mountExtensionPreviews(el));
+    rendered.set(el, source);
   }
   for (const [anchor, attr, tag] of [["image", "src", "IMG"], ["alt", "alt", "IMG"], ["href", "href", "A"]]) {
     for (const el of doc.querySelectorAll(`[data-rigel-${anchor}]`)) {

package/src/routes/local-api.ts

@@ -1,4 +1,5 @@
 import type { APIRoute } from "astro";
+import { requestTranslator } from "../editor/i18n/server";
 import { writeFile, readFile } from "node:fs/promises";
 import path from "node:path";
 import { applyValues } from "./serialize";
@@ -6,6 +7,7 @@ import { applyValues } from "./serialize";
 export const prerender = false;
 
 export const POST: APIRoute = async ({ request }) => {
+  const t = requestTranslator(request);
   if (import.meta.env.PROD) {
     return new Response("Local backend is dev-only", { status: 404 });
   }
@@ -18,21 +20,21 @@ export const POST: APIRoute = async ({ request }) => {
   }
   const slug = String(body.slug ?? "");
   const values = body.values ?? {};
-  if (!slug) return new Response("Missing slug", { status: 400 });
+  if (!slug) return new Response(t("local.missingSlug"), { status: 400 });
 
   const file = path.resolve("src/content/copy", `${slug}.ts`);
   let source: string;
   try {
     source = await readFile(file, "utf8");
   } catch {
-    return new Response(`No copy module for ${slug}`, { status: 404 });
+    return new Response(t("local.copyNotFound", { slug }), { status: 404 });
   }
 
   let next: string;
   try {
     next = applyValues(source, values);
   } catch {
-    return new Response(`Could not locate values block in ${slug}.ts`, {
+    return new Response(t("local.copyValuesNotFound", { slug }), {
       status: 422,
     });
   }

package/src/routes/local-documents.ts

@@ -1,4 +1,6 @@
 import type { APIRoute } from "astro";
+import { requestTranslator } from "../editor/i18n/server";
+import type { Translator } from "../editor/i18n/format";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import config from "virtual:rigel-config";
@@ -16,18 +18,18 @@ function guard(): { schema: Schema; root: string } | Response {
   return { schema: config.schema as Schema, root: fileURLToPath(config.root) };
 }
 
-async function readBody(request: Request): Promise<Record<string, unknown>> {
+async function readBody(request: Request, t: Translator): Promise<Record<string, unknown>> {
   const length = Number(request.headers.get("content-length") ?? "0");
-  if (length > MAX_BODY) throw new DocumentStoreError("Document exceeds the 1 MiB limit", 413);
+  if (length > MAX_BODY) throw new DocumentStoreError(t("local.documentTooLarge"), 413);
   const raw = await request.text();
-  if (Buffer.byteLength(raw) > MAX_BODY) throw new DocumentStoreError("Document exceeds the 1 MiB limit", 413);
+  if (Buffer.byteLength(raw) > MAX_BODY) throw new DocumentStoreError(t("local.documentTooLarge"), 413);
   let body: unknown;
   try {
     body = JSON.parse(raw);
   } catch {
     throw new DocumentStoreError("Invalid JSON", 400);
   }
-  if (!isPlainObject(body) || !isPlainObject(body.data)) throw new DocumentStoreError("Body requires a data object", 400);
+  if (!isPlainObject(body) || !isPlainObject(body.data)) throw new DocumentStoreError(t("local.dataRequired"), 400);
   return body.data;
 }
 
@@ -39,42 +41,44 @@ function decodeParam(value: string): string {
   }
 }
 
-export const GET: APIRoute = async ({ params }) => {
+export const GET: APIRoute = async ({ request, params }) => {
+  const t = requestTranslator(request);
   const guarded = guard();
   if (guarded instanceof Response) return guarded;
   const id = decodeParam(String(params.id ?? ""));
   const target = validateDocumentId(guarded.schema, id);
-  if (!target) return new Response("Unknown document", { status: 404 });
+  if (!target) return new Response(t("local.unknownDocument"), { status: 404 });
   try {
-    const documents = await readDocuments(guarded.schema, guarded.root, config.preview);
+    const documents = await readDocuments(guarded.schema, guarded.root, config.preview, t);
     const document = documents.find((entry) => entry.id === id);
-    if (!document) return new Response("Unknown document", { status: 404 });
+    if (!document) return new Response(t("local.unknownDocument"), { status: 404 });
     return Response.json(document);
   } catch (error) {
     if (error instanceof DocumentStoreError) return new Response(error.message, { status: error.status });
-    return new Response("Could not read document", { status: 500 });
+    return new Response(t("local.readDocumentFailed"), { status: 500 });
   }
 };
 
 const handle: APIRoute = async ({ request, params }) => {
+  const t = requestTranslator(request);
   const guarded = guard();
   if (guarded instanceof Response) return guarded;
-  if (request.method === "DELETE") return new Response("Documents are created and removed by the site developer", { status: 405, headers: { Allow: "GET, POST, PUT" } });
+  if (request.method === "DELETE") return new Response(t("local.documentDeveloperOnly"), { status: 405, headers: { Allow: "GET, POST, PUT" } });
   if (request.headers.get("Origin") !== new URL(request.url).origin) return new Response("Same-origin request required", { status: 403 });
   const id = decodeParam(String(params.id ?? ""));
   const target = validateDocumentId(guarded.schema, id);
-  if (!target) return new Response("Unknown document type or slug", { status: 400 });
+  if (!target) return new Response(t("local.unknownDocumentTarget"), { status: 400 });
   try {
-    const data = await readBody(request);
-    const documents = await readDocuments(guarded.schema, guarded.root, config.preview);
+    const data = await readBody(request, t);
+    const documents = await readDocuments(guarded.schema, guarded.root, config.preview, t);
     const next = { ...data, _id: id, _type: target.type.name };
-    validateDocument(guarded.schema, target.type.name, target.slug, next, documents);
-    await writeDocument(guarded.schema, guarded.root, target.type.name, target.slug, next, request.method === "POST" ? "create" : "update", config.preview, config.jsonOutput);
+    validateDocument(guarded.schema, target.type.name, target.slug, next, documents, t);
+    await writeDocument(guarded.schema, guarded.root, target.type.name, target.slug, next, request.method === "POST" ? "create" : "update", config.preview, config.jsonOutput, t);
     return new Response(null, { status: 204 });
   } catch (error) {
     if (error instanceof DocumentStoreError) return new Response(error.message, { status: error.status });
     if (error instanceof SchemaError) return new Response(error.message, { status: 400 });
-    return new Response("Could not save document", { status: 500 });
+    return new Response(t("local.saveDocumentFailed"), { status: 500 });
   }
 };
 

package/src/routes/local-media.ts

@@ -1,4 +1,5 @@
 import type { APIRoute } from "astro";
+import { requestTranslator } from "../editor/i18n/server";
 import { randomUUID } from "node:crypto";
 import { lstat, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -11,9 +12,10 @@ import config from "virtual:rigel-config";
 export const prerender = false;
 
 export const GET: APIRoute = async ({ params, request }) => {
+  const t = requestTranslator(request);
   const filename = params.filename ?? "";
   if (import.meta.env.PROD || !safeMediaName(filename) || filename.startsWith(".") || /[/\\\u0000]/.test(filename)) {
-    return new Response("Not found", { status: 404 });
+    return new Response(t("local.notFound"), { status: 404 });
   }
   try {
     const file = path.join(await mediaDirectory(config.publicDir!, config.mediaDir), filename);
@@ -21,11 +23,12 @@ export const GET: APIRoute = async ({ params, request }) => {
     const bytes = await readFile(file);
     return new Response(new Uint8Array(bytes), { headers: mediaHeaders(filename, new URL(request.url).searchParams.get("preview") === "1") });
   } catch {
-    return new Response("Not found", { status: 404 });
+    return new Response(t("local.notFound"), { status: 404 });
   }
 };
 
 export const POST: APIRoute = async ({ request }) => {
+  const t = requestTranslator(request);
   if (import.meta.env.PROD) {
     return new Response("Local backend is dev-only", { status: 404 });
   }
@@ -36,16 +39,16 @@ export const POST: APIRoute = async ({ request }) => {
   const supplied = request.headers.get("X-Rigel-Filename");
   const fallback = ({ "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp" } as Record<string, string>)[mime ?? ""];
   const metadata = supplied ? (safeMediaName(supplied) ? mediaMetadata(supplied) : undefined) : fallback ? mediaMetadata(`image.${fallback}`) : undefined;
-  if (!metadata || metadata.type !== mime) return new Response("Unsupported or mismatched media type/filename", { status: 415 });
+  if (!metadata || metadata.type !== mime) return new Response(t("local.unsupportedMedia"), { status: 415 });
   const limit = config.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
   const length = request.headers.get("Content-Length");
   if (length !== null && !/^\d+$/.test(length)) {
     return new Response("Invalid Content-Length", { status: 400 });
   }
   if (length !== null && Number(length) > limit) {
-    return new Response(`Media exceeds ${limit / 1024 / 1024} MB`, { status: 413 });
+    return new Response(t("local.mediaTooLarge", { limit: limit / 1024 / 1024 }), { status: 413 });
   }
-  if (!request.body) return new Response("Empty media body", { status: 400 });
+  if (!request.body) return new Response(t("local.emptyMedia"), { status: 400 });
   const chunks: Uint8Array[] = [];
   let size = 0;
   const reader = request.body.getReader();
@@ -56,19 +59,19 @@ export const POST: APIRoute = async ({ request }) => {
       size += value.byteLength;
       if (size > limit) {
         void reader.cancel().catch(() => {});
-        return new Response(`Media exceeds ${limit / 1024 / 1024} MB`, { status: 413 });
+        return new Response(t("local.mediaTooLarge", { limit: limit / 1024 / 1024 }), { status: 413 });
       }
       chunks.push(value);
     }
   } catch {
-    return new Response("Could not read image body", { status: 400 });
+    return new Response(t("local.readImageFailed"), { status: 400 });
   } finally {
     reader.releaseLock();
   }
   const bytes = Buffer.concat(chunks, size);
-  if (!bytes.length) return new Response("Empty image body", { status: 400 });
+  if (!bytes.length) return new Response(t("local.emptyImage"), { status: 400 });
   const extension = metadata.extension === "jpeg" ? "jpg" : metadata.extension;
-  if (!validMediaBytes(bytes, extension)) return new Response("Media type does not match its bytes", { status: 415 });
+  if (!validMediaBytes(bytes, extension)) return new Response(t("local.mediaBytesMismatch"), { status: 415 });
   const filename = `${randomUUID()}.${extension}`;
   let url = "";
   try {
@@ -80,12 +83,13 @@ export const POST: APIRoute = async ({ request }) => {
     const author = (request.headers.get("X-Rigel-Author") ?? "").trim().replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 80);
     await updateMediaSidecar(directory, url, author ? { author } : {}, { name: (supplied ?? filename).slice(0, 120) });
   } catch {
-    return new Response("Could not save image", { status: 500 });
+    return new Response(t("local.saveImageFailed"), { status: 500 });
   }
   return Response.json({ url });
   };
 
   export const PUT: APIRoute = async ({ request }) => {
+  const t = requestTranslator(request);
     if (import.meta.env.PROD) {
       return new Response("Local backend is dev-only", { status: 404 });
     }
@@ -96,9 +100,9 @@ export const POST: APIRoute = async ({ request }) => {
     try { body = await request.json(); } catch { return new Response("Invalid JSON body", { status: 400 }); }
     let directory: string;
     try { directory = await mediaDirectory(config.publicDir!, config.mediaDir, true); }
-    catch { return new Response("Media directory unavailable", { status: 500 }); }
+    catch { return new Response(t("local.mediaDirectoryUnavailable"), { status: 500 }); }
     const assets = await listMedia(config.publicDir!, config.mediaDir);
-    const valid = validateMetaUpdate(body, new Set(assets.map(asset => asset.url)));
+    const valid = validateMetaUpdate(body, new Set(assets.map(asset => asset.url)), t);
     if (!valid.ok) return new Response(valid.error, { status: 400 });
     const patch: { name?: string; title?: string; description?: string; alt?: string } = {};
     if (valid.value.name !== undefined) patch.name = valid.value.name;
@@ -109,21 +113,22 @@ export const POST: APIRoute = async ({ request }) => {
       const file = path.join(fileURLToPath(config.publicDir!), ...valid.value.url.slice(1).split("/").map(decodeURIComponent));
       await updateMediaSidecar(directory, valid.value.url, patch, {}, file);
     } catch (error) {
-      return new Response("Could not save metadata", { status: (error as NodeJS.ErrnoException).code === "ENOENT" ? 404 : 500 });
+      return new Response(t("local.saveMetadataFailed"), { status: (error as NodeJS.ErrnoException).code === "ENOENT" ? 404 : 500 });
     }
     return Response.json((await listMedia(config.publicDir!, config.mediaDir)).find(asset => asset.url === valid.value.url) ?? { url: valid.value.url });
   };
 
 export const DELETE: APIRoute = async ({ request }) => {
+  const t = requestTranslator(request);
   if (import.meta.env.PROD) return new Response("Local backend is dev-only", { status: 404 });
   if (request.headers.get("Origin") !== new URL(request.url).origin) return new Response("Same-origin request required", { status: 403 });
   let body: unknown;
   try { body = await request.json(); } catch { return new Response("Invalid JSON body", { status: 400 }); }
-  if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length !== 1 || !("url" in body) || typeof body.url !== "string") return new Response("A media URL is required", { status: 400 });
+  if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length !== 1 || !("url" in body) || typeof body.url !== "string") return new Response(t("local.mediaUrlRequired"), { status: 400 });
   try {
-    if (!await deleteMediaFile(config.publicDir!, config.mediaDir, body.url)) return new Response("File not found", { status: 404 });
+    if (!await deleteMediaFile(config.publicDir!, config.mediaDir, body.url)) return new Response(t("local.fileNotFound"), { status: 404 });
     return new Response(null, { status: 204 });
   } catch {
-    return new Response("Could not delete file. Try again.", { status: 500 });
+    return new Response(t("local.deleteFileFailed"), { status: 500 });
   }
 };

package/src/routes/local-menu.ts

@@ -1,4 +1,5 @@
 import type { APIRoute } from "astro";
+import { requestTranslator } from "../editor/i18n/server";
 import { serializeContentJson } from "../json-output";
 import { constants } from "node:fs";
 import { lstat, open, realpath, rename, unlink } from "node:fs/promises";
@@ -28,20 +29,21 @@ async function menuFile(slug: string): Promise<string> {
 }
 
 const handle: APIRoute = async ({ request, params }) => {
+  const t = requestTranslator(request);
   if (import.meta.env.PROD || config.backend !== "local" || !config.menus)
     return new Response("Local menus are not enabled", { status: 404 });
   const slug = params.slug ?? "";
-  if (!MENU_SLUG.test(slug)) return new Response("Invalid menu slug", { status: 400 });
+  if (!MENU_SLUG.test(slug)) return new Response(t("local.invalidMenuSlug"), { status: 400 });
   const method = request.method;
   if (method !== "GET" && method !== "PUT")
-    return new Response("Menus are declared by the site developer. Only existing menus can be edited.", { status: 405, headers: { Allow: "GET, PUT" } });
+    return new Response(t("local.menuDeveloperOnly"), { status: 405, headers: { Allow: "GET, PUT" } });
   if (method !== "GET" && request.headers.get("Origin") !== new URL(request.url).origin)
     return new Response("Same-origin request required", { status: 403 });
   let menu: MenuDocument | undefined;
   if (method === "PUT") {
     try {
-      menu = validateMenu(await request.json(), config.menus.maxDepth ?? 3);
-      if (menu.slug !== slug) throw new Error("Menu slug must match the request slug");
+      menu = validateMenu(await request.json(), config.menus.maxDepth ?? 3, t);
+      if (menu.slug !== slug) throw new Error(t("local.menuSlugMismatch"));
     } catch (error) {
       return new Response(error instanceof SyntaxError ? "Invalid JSON" : (error as Error).message, { status: 400 });
     }
@@ -52,7 +54,7 @@ const handle: APIRoute = async ({ request, params }) => {
     if (method === "GET") {
       const input = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
       try {
-        const result = validateMenu(JSON.parse(await input.readFile("utf8")), config.menus.maxDepth ?? 3);
+        const result = validateMenu(JSON.parse(await input.readFile("utf8")), config.menus.maxDepth ?? 3, t);
         if (result.slug !== slug) throw new Error("Stored menu slug does not match filename");
         return Response.json(result);
       } finally { await input.close(); }
@@ -69,8 +71,8 @@ const handle: APIRoute = async ({ request, params }) => {
     return new Response(null, { status: 204 });
   } catch (error) {
     const code = (error as NodeJS.ErrnoException).code;
-    if (code === "ENOENT") return new Response("No such menu", { status: 404 });
-    return new Response("Could not access menu: invalid stored data or unsafe/unavailable storage", { status: 500 });
+    if (code === "ENOENT") return new Response(t("local.menuNotFound"), { status: 404 });
+    return new Response(t("local.menuStorageUnavailable"), { status: 500 });
   } finally {
     if (temporary) await unlink(temporary).catch(() => {});
   }