@rigel-cms/rigel 1.0.0 → 1.1.0

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);
@@ -70,7 +71,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

@@ -50,6 +50,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;

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,13 @@ function rebindTree(root: Element | DocumentFragment, update: (element: Element)
 }
 
 export function patchPreview(doc: Document, values: Record<string, unknown>, body: "" | import("./article-body").ArticleBody, options: PatchDocuments = {}) {
+  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 {};
@@ -169,11 +185,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 +197,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(() => {});
   }

package/src/routes/local-post.ts

@@ -1,4 +1,5 @@
 import type { APIRoute } from "astro";
+import { requestTranslator } from "../editor/i18n/server";
 import { serializeContentJson } from "../json-output";
 import { writeFile, mkdir, rm, readFile, readdir, rename, link } from "node:fs/promises";
 import { assertUniqueUrlSlugs, normalizeUrlSlug } from "../slugs";
@@ -7,6 +8,8 @@ import path from "node:path";
 
 import { validateBody, type ArticleBody } from "../article-body";
 import config from "virtual:rigel-config";
+import extensions from "virtual:rigel-extensions";
+import { resolveExtensions, validateExtensionBlocks } from "../extensions";
 import { validateCollectionValues } from "../manifest/collections";
 import { readDocuments } from "../schema/store";
 import { fileURLToPath } from "node:url";
@@ -33,35 +36,37 @@ export const POST: APIRoute = (context) => {
 };
 
 const savePost: APIRoute = async ({ request, params }) => {
+  const t = requestTranslator(request);
   if (import.meta.env.PROD) {
     return new Response("Local backend is dev-only", { status: 404 });
   }
   const folder = collectionFolder(String(params.collection ?? ""));
   const slug = safeSlug(String(params.slug ?? ""));
   if (!folder || !slug) {
-    return new Response("Unknown collection/slug", { status: 404 });
+    return new Response(t("local.unknownCollectionSlug"), { status: 404 });
   }
 
   let body: { frontmatter: Record<string, unknown>; body: ArticleBody };
   try {
     body = await request.json();
-    if (!body || typeof body !== "object" || !body.frontmatter || typeof body.frontmatter !== "object" || Array.isArray(body.frontmatter)) throw new Error("Invalid article");
+    if (!body || typeof body !== "object" || !body.frontmatter || typeof body.frontmatter !== "object" || Array.isArray(body.frontmatter)) throw new Error(t("local.invalidArticle"));
   } catch {
     return new Response("Invalid JSON", { status: 400 });
   }
 
   const file = path.resolve(folder, `${slug}.json`);
   try {
-    validateBody(body.body);
+    validateBody(body.body, t);
+    validateExtensionBlocks(body.body, resolveExtensions(extensions).blocks);
     const fields = config.collections?.find((collection: CollectionConfig) => collection.name === params.collection)?.fields ?? [];
-    const documents = config.schema && config.root ? await readDocuments(config.schema, fileURLToPath(config.root), config.preview) : [];
-    validateCollectionValues(fields, body.frontmatter, documents);
-    if (Object.hasOwn(body.frontmatter, "slug")) body.frontmatter.slug = normalizeUrlSlug(body.frontmatter.slug);
+    const documents = config.schema && config.root ? await readDocuments(config.schema, fileURLToPath(config.root), config.preview, t) : [];
+    validateCollectionValues(fields, body.frontmatter, documents, t);
+    if (Object.hasOwn(body.frontmatter, "slug")) body.frontmatter.slug = normalizeUrlSlug(body.frontmatter.slug, t);
     const names = await readdir(folder).catch((error: NodeJS.ErrnoException) => { if (error.code === "ENOENT") return []; throw error; });
     const entries = await Promise.all(names.filter(name => name.endsWith(".json") && name !== `${slug}.json`).map(async name => ({ slug: name.slice(0, -5), values: JSON.parse(await readFile(path.join(folder, name), "utf8")).frontmatter })));
-    assertUniqueUrlSlugs([...entries, { slug, values: body.frontmatter }]);
+    assertUniqueUrlSlugs([...entries, { slug, values: body.frontmatter }], t);
   } catch (error) {
-    return new Response(error instanceof Error ? error.message : "Invalid article", { status: 400 });
+    return new Response(error instanceof Error ? error.message : t("local.invalidArticle"), { status: 400 });
   }
   await mkdir(path.dirname(file), { recursive: true });
   const fm = { ...body.frontmatter };
@@ -71,7 +76,7 @@ const savePost: APIRoute = async ({ request, params }) => {
     if (request.headers.get("If-None-Match") === "*") {
       try { await link(temporary, file); }
       catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "EEXIST") return new Response("A post with that slug already exists. Reload the collection and create the draft again.", { status: 409 });
+        if ((error as NodeJS.ErrnoException).code === "EEXIST") return new Response(t("local.postExists"), { status: 409 });
         throw error;
       }
     } else await rename(temporary, file);
@@ -79,20 +84,21 @@ const savePost: APIRoute = async ({ request, params }) => {
   return new Response(null, { status: 204 });
 };
 
-export const DELETE: APIRoute = async ({ params }) => {
+export const DELETE: APIRoute = async ({ request, params }) => {
+  const t = requestTranslator(request);
   if (import.meta.env.PROD) {
     return new Response("Local backend is dev-only", { status: 404 });
   }
   const folder = collectionFolder(String(params.collection ?? ""));
   const slug = safeSlug(String(params.slug ?? ""));
   if (!folder || !slug) {
-    return new Response("Unknown collection/slug", { status: 404 });
+    return new Response(t("local.unknownCollectionSlug"), { status: 404 });
   }
   const file = path.resolve(folder, `${slug}.json`);
   try {
     await readFile(file); // only delete existing files
   } catch {
-    return new Response("No such post", { status: 404 });
+    return new Response(t("local.postNotFound"), { status: 404 });
   }
   await rm(file);
   return new Response(null, { status: 204 });

package/src/routes/media-files.ts

@@ -2,6 +2,7 @@ import { lstat, mkdir, readFile, readdir, realpath, rename, unlink, writeFile }
 import path from "node:path";
 import { mediaMetadata, safeMediaName } from "../media-types";
 import { fileURLToPath } from "node:url";
+import { systemMessage, type Translator } from "../editor/i18n/format";
 
 export const imageFile = /\\.(jpe?g|png|webp|gif|avif)$/i;
 const SIDECAR = ".rigel-media.json";
@@ -106,29 +107,30 @@ export function deleteMediaFile(publicDir: string, folder: string | undefined, u
 export function validateMetaUpdate(
   body: unknown,
   existing: Set<string>,
+  message: Translator = systemMessage,
 ): { ok: true; value: { url: string; name?: string; title?: string; description?: string; alt?: string } } | { ok: false; error: string } {
-  if (!body || typeof body !== "object" || Array.isArray(body)) return { ok: false, error: "Invalid request body" };
+  if (!body || typeof body !== "object" || Array.isArray(body)) return { ok: false, error: message("local.invalidMetadataBody") };
   const b = body as Record<string, unknown>;
   const allowed = ["url", "name", "title", "description", "alt"];
-  if (Object.keys(b).some(key => !allowed.includes(key))) return { ok: false, error: "Unknown metadata field" };
-  if (typeof b.url !== "string" || !existing.has(b.url)) return { ok: false, error: "Unknown asset" };
+  if (Object.keys(b).some(key => !allowed.includes(key))) return { ok: false, error: message("local.unknownMetadataField") };
+  if (typeof b.url !== "string" || !existing.has(b.url)) return { ok: false, error: message("local.unknownAsset") };
   const value: { url: string; name?: string; title?: string; description?: string; alt?: string } = { url: b.url };
   if ("name" in b) {
     const candidate = typeof b.name === "string" ? b.name.trim() : b.name;
-    if (!safeDisplayName(candidate)) return { ok: false, error: "Invalid display name" };
+    if (!safeDisplayName(candidate)) return { ok: false, error: message("local.invalidDisplayName") };
     value.name = typeof candidate === "string" ? candidate : undefined;
   }
   if ("title" in b) {
-    if (typeof b.title !== "string") return { ok: false, error: "Title must be a string" };
+    if (typeof b.title !== "string") return { ok: false, error: message("local.metadataTitleString") };
     value.title = sanitize(b.title, 200);
   }
   if ("description" in b) {
-    if (typeof b.description !== "string") return { ok: false, error: "Description must be a string" };
+    if (typeof b.description !== "string") return { ok: false, error: message("local.metadataDescriptionString") };
     value.description = sanitize(b.description, 1000);
   }
   if ("alt" in b) {
-    if (typeof b.alt !== "string") return { ok: false, error: "Alt text must be a string" };
-    if (!mediaMetadata(b.url)?.type.startsWith("image/")) return { ok: false, error: "Alt text is only available for images" };
+    if (typeof b.alt !== "string") return { ok: false, error: message("local.metadataAltString") };
+    if (!mediaMetadata(b.url)?.type.startsWith("image/")) return { ok: false, error: message("local.metadataAltImagesOnly") };
     value.alt = sanitize(b.alt.replace(/\s+/g, " "), 1000) ?? "";
   }
   return { ok: true, value };