@rigel-cms/rigel 1.0.0-rc.1 → 1.1.0

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 };

package/src/routes/rigel-page.astro

@@ -1,4 +1,5 @@
 ---
+import messages from "../editor/i18n/en/system.json";
 ---
 <!doctype html>
 <html lang="en">
@@ -6,7 +7,7 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="robots" content="noindex, nofollow" />
-    <title>Rigel — Content Editor</title>
+    <title>{messages["system.editorTitle"]}</title>
     <style>
       *, *::before, *::after { box-sizing: border-box; }
       html { background: #F8FAFC; color-scheme: light; }

package/src/schema/store.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { systemMessage, type Translator } from "../editor/i18n/format";
 import { link, lstat, mkdir, open, readdir, realpath, rename, unlink } from "node:fs/promises";
 import path from "node:path";
 import { constants } from "node:fs";
@@ -41,10 +42,10 @@ async function resolveFolder(root: string, folder: string): Promise<string> {
   return directory;
 }
 
-async function readJsonFile(file: string): Promise<unknown> {
+async function readJsonFile(file: string, t: Translator): Promise<unknown> {
   const info = await lstat(file);
   if (info.isSymbolicLink() || !info.isFile()) throw new DocumentStoreError("Document must be a regular file", 500);
-  if (info.size > MAX_BYTES) throw new DocumentStoreError("Document exceeds the 1 MiB limit", 413);
+  if (info.size > MAX_BYTES) throw new DocumentStoreError(t("local.documentTooLarge"), 413);
   const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
   try {
     return JSON.parse(await handle.readFile("utf8"));
@@ -71,7 +72,7 @@ async function ensureFolder(root: string, folder: string): Promise<string> {
   return directory;
 }
 
-export async function readDocuments(schema: Schema, root: string, preview?: PreviewConfig): Promise<ContentDocument[]> {
+export async function readDocuments(schema: Schema, root: string, preview?: PreviewConfig, t: Translator = systemMessage): Promise<ContentDocument[]> {
   const documents: ContentDocument[] = [];
   for (const type of schema.documents) {
     let directory: string;
@@ -85,19 +86,19 @@ export async function readDocuments(schema: Schema, root: string, preview?: Prev
     for (const name of names) {
       const slug = name.slice(0, -5);
       if (!SLUG_PATTERN.test(slug)) throw new DocumentStoreError(`Invalid document filename ${name}`, 500);
-      const data = await readJsonFile(path.join(directory, name));
+      const data = await readJsonFile(path.join(directory, name), t);
       if (!isPlainObject(data)) throw new DocumentStoreError(`Document ${name} must be a JSON object`, 500);
       if (data._type !== undefined && data._type !== type.name) throw new DocumentStoreError(`${name}: _type must be ${type.name}`, 500);
       documents.push({ id: `${type.name}:${slug}`, type: type.name, slug, data: data as Record<string, unknown> });
     }
   }
-  try { validateDocumentSlugs(schema, documents, preview); }
+  try { validateDocumentSlugs(schema, documents, preview, t); }
   catch (error) { throw new DocumentStoreError((error as Error).message); }
   return documents;
 }
 
-export async function readDocument(schema: Schema, root: string, typeName: string, slug: string): Promise<ContentDocument | null> {
-  const documents = await readDocuments(schema, root);
+export async function readDocument(schema: Schema, root: string, typeName: string, slug: string, t: Translator = systemMessage): Promise<ContentDocument | null> {
+  const documents = await readDocuments(schema, root, undefined, t);
   return documents.find((doc) => doc.type === typeName && doc.slug === slug) ?? null;
 }
 
@@ -117,12 +118,13 @@ async function writeDocumentFile(
   mode: "create" | "update",
   preview?: PreviewConfig,
   jsonOutput?: JsonOutput,
+  t: Translator = systemMessage,
 ): Promise<void> {
   const type = schema.documents.find((entry) => entry.name === typeName);
-  if (!type) throw new DocumentStoreError(`Unknown document type ${typeName}`, 404);
-  if (mode === "create" && (type.creatable === false || type.singleton)) throw new DocumentStoreError("Creating entries is disabled for this document type", 403);
-  if (!SLUG_PATTERN.test(slug)) throw new DocumentStoreError("Invalid document slug", 400);
-  if (!isPlainObject(data)) throw new DocumentStoreError("Document must be an object", 400);
+  if (!type) throw new DocumentStoreError(t("local.unknownDocumentType", { type: typeName }), 404);
+  if (mode === "create" && (type.creatable === false || type.singleton)) throw new DocumentStoreError(t("local.creatingDisabled"), 403);
+  if (!SLUG_PATTERN.test(slug)) throw new DocumentStoreError(t("local.invalidDocumentSlug"), 400);
+  if (!isPlainObject(data)) throw new DocumentStoreError(t("local.documentObjectRequired"), 400);
   const directory = await ensureFolder(root, type.folder);
   const file = path.join(directory, `${slug}.json`);
   const existing = await lstat(file).catch((error: NodeJS.ErrnoException) => {
@@ -130,17 +132,17 @@ async function writeDocumentFile(
     throw error;
   });
   if (existing && (existing.isSymbolicLink() || !existing.isFile())) throw new DocumentStoreError("Document path is unsafe", 409);
-  if (mode === "create" && existing) throw new DocumentStoreError("A document with that slug already exists", 409);
-  if (mode === "update" && !existing) throw new DocumentStoreError("No such document", 404);
-  if (Buffer.byteLength(JSON.stringify(data)) > MAX_BYTES) throw new DocumentStoreError("Document exceeds the 1 MiB limit", 413);
+  if (mode === "create" && existing) throw new DocumentStoreError(t("local.documentExists"), 409);
+  if (mode === "update" && !existing) throw new DocumentStoreError(t("local.documentNotFound"), 404);
+  if (Buffer.byteLength(JSON.stringify(data)) > MAX_BYTES) throw new DocumentStoreError(t("local.documentTooLarge"), 413);
   data = { ...data };
   try {
-    if (!type.shared && Object.hasOwn(data, "slug")) data.slug = normalizeUrlSlug(data.slug);
-    const documents = await readDocuments(schema, root, preview);
-    validateDocumentSlugs(schema, [...documents.filter(doc => doc.id !== `${typeName}:${slug}`), { id: `${typeName}:${slug}`, type: typeName, slug, data }], preview);
+    if (!type.shared && Object.hasOwn(data, "slug")) data.slug = normalizeUrlSlug(data.slug, t);
+    const documents = await readDocuments(schema, root, preview, t);
+    validateDocumentSlugs(schema, [...documents.filter(doc => doc.id !== `${typeName}:${slug}`), { id: `${typeName}:${slug}`, type: typeName, slug, data }], preview, t);
   } catch (error) { throw new DocumentStoreError((error as Error).message); }
   const serialized = serializeContentJson(data, jsonOutput);
-  if (Buffer.byteLength(serialized) > MAX_BYTES) throw new DocumentStoreError("Document exceeds the 1 MiB limit", 413);
+  if (Buffer.byteLength(serialized) > MAX_BYTES) throw new DocumentStoreError(t("local.documentTooLarge"), 413);
   const temporary = path.join(directory, `.${slug}-${randomUUID()}.tmp`);
   try {
     const handle = await open(temporary, "wx", 0o600);
@@ -154,8 +156,8 @@ async function writeDocumentFile(
     else await rename(temporary, file);
   } catch (error) {
     if (error instanceof DocumentStoreError) throw error;
-    if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new DocumentStoreError("A document with that slug already exists", 409);
-    throw new DocumentStoreError("Could not write document", 500);
+    if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new DocumentStoreError(t("local.documentExists"), 409);
+    throw new DocumentStoreError(t("local.writeDocumentFailed"), 500);
   } finally {
     await unlink(temporary).catch(() => {});
   }

package/src/schema/types.ts

@@ -8,6 +8,7 @@ export type ArrayItem =
 export interface FieldDef {
   key: string;
   label: string;
+  labelKey?: string;
   type: ScalarFieldType | "object" | "array" | "reference";
   placeholder?: string;
   required?: boolean;

package/src/schema/validate.ts

@@ -11,6 +11,7 @@ import {
   type ScalarFieldType,
   type Schema,
 } from "./types";
+import { systemMessage, type Parameters, type Translator } from "../editor/i18n/format";
 
 const SCALARS: ScalarFieldType[] = ["string", "text", "markdown", "boolean", "number", "date", "image", "url", "color", "code", "password"];
 const UNSAFE = new Set(["__proto__", "constructor", "prototype"]);
@@ -24,19 +25,19 @@ export function isPlainObject(value: unknown): value is Record<string, unknown>
   return proto === Object.prototype || proto === null;
 }
 
-function fail(path: string, message: string): never {
-  throw new SchemaError(`${path}: ${message}`);
+function fail(path: string, key: string, message: Translator = systemMessage, parameters: Parameters = {}): never {
+  throw new SchemaError(message(key, { path, ...parameters }));
 }
 
-export function objectDef(schema: Schema, name: string): ObjectDef {
+export function objectDef(schema: Schema, name: string, message: Translator = systemMessage): ObjectDef {
   const def = schema.objects.find((entry) => entry.name === name);
-  if (!def) fail(name, "unknown object type");
+  if (!def) fail(name, "validation.schema.unknownObject", message);
   return def;
 }
 
-export function documentDef(schema: Schema, name: string): DocumentDef {
+export function documentDef(schema: Schema, name: string, message: Translator = systemMessage): DocumentDef {
   const def = schema.documents.find((entry) => entry.name === name);
-  if (!def) fail(name, "unknown document type");
+  if (!def) fail(name, "validation.schema.unknownDocument", message);
   return def;
 }
 
@@ -135,21 +136,21 @@ function scalarOk(type: ScalarFieldType, value: unknown): boolean {
   return true;
 }
 
-function requireValue(field: FieldDef, value: unknown, path: string) {
-  if (value === undefined || value === null) fail(path, "required");
-  if (typeof value === "string" && ["string", "text", "markdown", "image", "url"].includes(field.type) && !value.trim()) fail(path, "required");
-  if (field.required && Array.isArray(value) && !value.length) fail(path, "required");
+function requireValue(field: FieldDef, value: unknown, path: string, message: Translator) {
+  if (value === undefined || value === null) fail(path, "validation.schema.required", message);
+  if (typeof value === "string" && ["string", "text", "markdown", "image", "url"].includes(field.type) && !value.trim()) fail(path, "validation.schema.required", message);
+  if (field.required && Array.isArray(value) && !value.length) fail(path, "validation.schema.required", message);
 }
 
-function checkKeys(value: unknown, path: string) {
+function checkKeys(value: unknown, path: string, message: Translator) {
   if (Array.isArray(value)) {
-    value.forEach((item, index) => checkKeys(item, `${path}[${index}]`));
+    value.forEach((item, index) => checkKeys(item, `${path}[${index}]`, message));
     return;
   }
   if (!isPlainObject(value)) return;
   for (const [key, child] of Object.entries(value)) {
-    if (UNSAFE.has(key)) fail(path, `unsafe key ${key}`);
-    checkKeys(child, `${path}.${key}`);
+    if (UNSAFE.has(key)) fail(path, "validation.schema.unsafeKey", message, { key });
+    checkKeys(child, `${path}.${key}`, message);
   }
 }
 
@@ -159,74 +160,75 @@ function validateObjectFields(
   value: Record<string, unknown>,
   path: string,
   documents: ContentDocument[],
+  message: Translator,
 ) {
   for (const field of fields) {
-    if (field.required) requireValue(field, value[field.key], `${path}.${field.key}`);
+    if (field.required) requireValue(field, value[field.key], `${path}.${field.key}`, message);
     if (value[field.key] === undefined) continue;
-    validateFieldValue(schema, field, value[field.key], `${path}.${field.key}`, documents);
+    validateFieldValue(schema, field, value[field.key], `${path}.${field.key}`, documents, message);
   }
   for (const key of Object.keys(value)) {
-    if (UNSAFE.has(key)) fail(path, `unsafe key ${key}`);
+    if (UNSAFE.has(key)) fail(path, "validation.schema.unsafeKey", message, { key });
   }
 }
 
-function validateFieldValue(schema: Schema, field: FieldDef, value: unknown, path: string, documents: ContentDocument[]) {
+function validateFieldValue(schema: Schema, field: FieldDef, value: unknown, path: string, documents: ContentDocument[], message: Translator) {
   if (field.type === "object") {
-    if (!isPlainObject(value)) fail(path, "must be an object");
-    checkKeys(value, path);
-    const def = field.of ? objectDef(schema, field.of) : undefined;
-    validateObjectFields(schema, def?.fields ?? field.fields ?? [], value, path, documents);
+    if (!isPlainObject(value)) fail(path, "validation.schema.object", message);
+    checkKeys(value, path, message);
+    const def = field.of ? objectDef(schema, field.of, message) : undefined;
+    validateObjectFields(schema, def?.fields ?? field.fields ?? [], value, path, documents, message);
     return;
   }
   if (field.type === "array") {
-    if (!Array.isArray(value)) fail(path, "must be an array");
-    if (field.min !== undefined && value.length < field.min) fail(path, `needs at least ${field.min} items`);
-    if (field.max !== undefined && value.length > field.max) fail(path, `allows at most ${field.max} items`);
-    checkKeys(value, path);
+    if (!Array.isArray(value)) fail(path, "validation.schema.array", message);
+    if (field.min !== undefined && value.length < field.min) fail(path, "validation.schema.minItems", message, { min: field.min });
+    if (field.max !== undefined && value.length > field.max) fail(path, "validation.schema.maxItems", message, { max: field.max });
+    checkKeys(value, path, message);
     const keys = new Set<string>();
     value.forEach((item, index) => {
       const itemPath = `${path}[${index}]`;
-      const def = matchItem(schema, field.items!, item, itemPath);
+      const def = matchItem(schema, field.items!, item, itemPath, message);
       if (def.type === "reference") {
-        if (!isPlainObject(item) || typeof item._ref !== "string") fail(itemPath, "must be a reference");
-        validateReference(schema, item, def.to ?? [], itemPath, documents);
+        if (!isPlainObject(item) || typeof item._ref !== "string") fail(itemPath, "validation.schema.reference", message);
+        validateReference(schema, item, def.to ?? [], itemPath, documents, message);
       } else if (def.type === "object") {
-        if (!isPlainObject(item)) fail(itemPath, "must be an object");
-        if (def.name && item._type !== def.name) fail(itemPath, `must be a ${def.name} section`);
-        checkKeys(item, itemPath);
-        validateObjectFields(schema, def.fields ?? objectDef(schema, def.name!).fields, item, itemPath, documents);
+        if (!isPlainObject(item)) fail(itemPath, "validation.schema.object", message);
+        if (def.name && item._type !== def.name) fail(itemPath, "validation.schema.section", message, { name: def.name });
+        checkKeys(item, itemPath, message);
+        validateObjectFields(schema, def.fields ?? objectDef(schema, def.name!, message).fields, item, itemPath, documents, message);
       } else if (!scalarOk(def.type as ScalarFieldType, item)) {
-        fail(itemPath, `must be a ${def.type}`);
+        fail(itemPath, "validation.schema.scalar", message, { type: def.type });
       }
       if (def.type === "object" || def.type === "reference") {
         const key = item && typeof item === "object" ? (item as Record<string, unknown>)._key : undefined;
-        if (typeof key !== "string" || !KEY_PATTERN.test(key)) fail(itemPath, "requires a stable _key");
-        if (keys.has(key as string)) fail(itemPath, `duplicate _key ${key}`);
+        if (typeof key !== "string" || !KEY_PATTERN.test(key)) fail(itemPath, "validation.schema.stableKey", message);
+        if (keys.has(key as string)) fail(itemPath, "validation.schema.duplicateKey", message, { key });
         keys.add(key as string);
       }
     });
     return;
   }
   if (field.type === "reference") {
-    if (!isPlainObject(value)) fail(path, "must be a reference");
-    validateReference(schema, value, field.to ?? [], path, documents);
+    if (!isPlainObject(value)) fail(path, "validation.schema.reference", message);
+    validateReference(schema, value, field.to ?? [], path, documents, message);
     return;
   }
   if ((field.type === "url" || field.type === "image") && value === "" && !field.required) return;
-  if (!scalarOk(field.type as ScalarFieldType, value)) fail(path, `must be a ${field.type}`);
+  if (!scalarOk(field.type as ScalarFieldType, value)) fail(path, "validation.schema.scalar", message, { type: field.type });
 }
 
 type ItemDef = { type: ScalarFieldType | "object" | "reference"; name?: string; fields?: FieldDef[]; to?: string[] };
 
-function matchItem(schema: Schema, items: ArrayItem[], item: unknown, path: string): ItemDef {
+function matchItem(schema: Schema, items: ArrayItem[], item: unknown, path: string, message: Translator): ItemDef {
   if (isPlainObject(item) && typeof item._type === "string") {
     const named = items.find((entry) => entry.type === "object" && entry.name === item._type);
-    if (named && named.type === "object") return { type: "object", name: named.name, fields: named.name ? objectDef(schema, named.name).fields : named.fields };
-    fail(path, `unknown section type ${item._type}`);
+    if (named && named.type === "object") return { type: "object", name: named.name, fields: named.name ? objectDef(schema, named.name, message).fields : named.fields };
+    fail(path, "validation.schema.unknownSection", message, { type: item._type });
   }
   if (items.length === 1) {
     const only = items[0];
-    if (only.type === "object") return { type: "object", name: only.name, fields: only.name ? objectDef(schema, only.name).fields : only.fields };
+    if (only.type === "object") return { type: "object", name: only.name, fields: only.name ? objectDef(schema, only.name, message).fields : only.fields };
     if (only.type === "reference") return { type: "reference", to: only.to };
     return only;
   }
@@ -236,22 +238,22 @@ function matchItem(schema: Schema, items: ArrayItem[], item: unknown, path: stri
   if (isPlainObject(item) && inline && inline.type === "object") return { type: "object", fields: inline.fields };
   const scalar = items.find((entry) => entry.type !== "object" && entry.type !== "reference" && scalarOk(entry.type, item));
   if (scalar) return scalar;
-  fail(path, "does not match an allowed array item type");
+  fail(path, "validation.schema.arrayItem", message);
 }
 
-function validateReference(schema: Schema, value: Record<string, unknown>, to: string[], path: string, documents: ContentDocument[]) {
+function validateReference(schema: Schema, value: Record<string, unknown>, to: string[], path: string, documents: ContentDocument[], message: Translator) {
   const ref = value._ref;
-  if (typeof ref !== "string" || !/^[a-z][a-zA-Z0-9-]*:[a-z0-9]+(?:-[a-z0-9]+)*$/.test(ref)) fail(path, "invalid reference id");
-  if (!to.some((name) => ref.startsWith(`${name}:`))) fail(path, `reference must target ${to.join(" or ")}`);
-  for (const key of Object.keys(value)) if (key !== "_ref" && !key.startsWith("_")) fail(path, `unknown reference property ${key}`);
-  if (!documents.some((doc) => doc.id === ref)) fail(path, `reference target ${ref} does not resolve`);
-  if (!schema.documents.some((doc) => ref.startsWith(`${doc.name}:`))) fail(path, `reference target type is not declared`);
+  if (typeof ref !== "string" || !/^[a-z][a-zA-Z0-9-]*:[a-z0-9]+(?:-[a-z0-9]+)*$/.test(ref)) fail(path, "validation.schema.referenceId", message);
+  if (!to.some((name) => ref.startsWith(`${name}:`))) fail(path, "validation.schema.referenceTarget", message, { targets: to.reduceRight((alternatives, target, index) => index === to.length - 1 ? target : message("validation.schema.referenceAlternatives", { target, alternatives }), "") });
+  for (const key of Object.keys(value)) if (key !== "_ref" && !key.startsWith("_")) fail(path, "validation.schema.referenceProperty", message, { key });
+  if (!documents.some((doc) => doc.id === ref)) fail(path, "validation.schema.unresolvedTarget", message, { ref });
+  if (!schema.documents.some((doc) => ref.startsWith(`${doc.name}:`))) fail(path, "validation.schema.undeclaredTarget", message);
 }
 
-export function documentIndex(documents: ContentDocument[]): { byId: Map<string, ContentDocument>; list: ContentDocument[] } {
+export function documentIndex(documents: ContentDocument[], message: Translator = systemMessage): { byId: Map<string, ContentDocument>; list: ContentDocument[] } {
   const byId = new Map<string, ContentDocument>();
   for (const doc of documents) {
-    if (byId.has(doc.id)) throw new SchemaError(`Duplicate document id: ${doc.id}`);
+    if (byId.has(doc.id)) throw new SchemaError(message("validation.schema.duplicateDocument", { id: doc.id }));
     byId.set(doc.id, doc);
   }
   return { byId, list: documents };
@@ -263,15 +265,16 @@ export function validateDocument(
   slug: string,
   data: Record<string, unknown>,
   documents: ContentDocument[],
+  message: Translator = systemMessage,
 ): Record<string, unknown> {
-  const def = documentDef(schema, typeName);
-  if (!SLUG_PATTERN.test(slug)) fail(slug, "slug must be lowercase letters, numbers and single dashes");
-  if (!isPlainObject(data)) fail(slug, "document must be an object");
-  if (data._type !== undefined && data._type !== typeName) fail(slug, `_type must be ${typeName}`);
-  if (data._id !== undefined && data._id !== `${typeName}:${slug}`) fail(slug, `_id must be ${typeName}:${slug}`);
-  checkKeys(data, slug);
-  validateObjectFields(schema, def.fields, data, slug, documents);
-  validateReferencesDeep(schema, def.fields, data, `${typeName}:${slug}`, `${typeName}:${slug}`, documents);
+  const def = documentDef(schema, typeName, message);
+  if (!SLUG_PATTERN.test(slug)) fail(slug, "validation.schema.slug", message);
+  if (!isPlainObject(data)) fail(slug, "validation.schema.documentObject", message);
+  if (data._type !== undefined && data._type !== typeName) fail(slug, "validation.schema.documentType", message, { type: typeName });
+  if (data._id !== undefined && data._id !== `${typeName}:${slug}`) fail(slug, "validation.schema.documentId", message, { id: `${typeName}:${slug}` });
+  checkKeys(data, slug, message);
+  validateObjectFields(schema, def.fields, data, slug, documents, message);
+  validateReferencesDeep(schema, def.fields, data, `${typeName}:${slug}`, `${typeName}:${slug}`, documents, message);
   return data;
 }
 
@@ -282,32 +285,33 @@ function validateReferencesDeep(
   path: string,
   self: string,
   documents: ContentDocument[],
+  message: Translator,
 ) {
   for (const field of fields) {
     const current = value[field.key];
     if (current === undefined) continue;
     if (field.type === "reference") {
       const ref = (current as Record<string, unknown>)._ref;
-      if (ref === self) fail(path, "a document cannot reference itself");
+      if (ref === self) fail(path, "validation.schema.selfReference", message);
       const target = documents.find((doc) => doc.id === ref);
-      if (!target) fail(`${path}.${field.key}`, `reference ${ref} does not resolve`);
+      if (!target) fail(`${path}.${field.key}`, "validation.schema.unresolvedReference", message, { ref: String(ref) });
       const def = schema.documents.find((doc) => doc.name === target.type);
-      if (!field.to?.includes(target.type) || !def) fail(`${path}.${field.key}`, `reference ${ref} is not an allowed target`);
+      if (!field.to?.includes(target.type) || !def) fail(`${path}.${field.key}`, "validation.schema.disallowedReference", message, { ref: String(ref) });
     } else if (field.type === "object" && isPlainObject(current)) {
-      const objectFields = field.of ? objectDef(schema, field.of).fields : field.fields ?? [];
-      validateReferencesDeep(schema, objectFields, current, `${path}.${field.key}`, self, documents);
+      const objectFields = field.of ? objectDef(schema, field.of, message).fields : field.fields ?? [];
+      validateReferencesDeep(schema, objectFields, current, `${path}.${field.key}`, self, documents, message);
     } else if (field.type === "array" && Array.isArray(current)) {
       current.forEach((item, index) => {
         if (!isPlainObject(item)) return;
         for (const entry of field.items ?? []) {
           if (entry.type === "reference" && typeof item._ref === "string") {
             const target = documents.find((doc) => doc.id === item._ref);
-            if (!target) fail(`${path}.${field.key}[${index}]`, `reference ${item._ref} does not resolve`);
-            if (!entry.to.includes(target.type)) fail(`${path}.${field.key}[${index}]`, `reference ${item._ref} is not an allowed target`);
+            if (!target) fail(`${path}.${field.key}[${index}]`, "validation.schema.unresolvedReference", message, { ref: String(item._ref) });
+            if (!entry.to.includes(target.type)) fail(`${path}.${field.key}[${index}]`, "validation.schema.disallowedReference", message, { ref: String(item._ref) });
           }
           if (entry.type === "object") {
-            const objectFields = entry.name ? objectDef(schema, entry.name).fields : entry.fields ?? [];
-            validateReferencesDeep(schema, objectFields, item, `${path}.${field.key}[${index}]`, self, documents);
+            const objectFields = entry.name ? objectDef(schema, entry.name, message).fields : entry.fields ?? [];
+            validateReferencesDeep(schema, objectFields, item, `${path}.${field.key}[${index}]`, self, documents, message);
           }
         }
       });

package/src/slugs.ts

@@ -1,5 +1,6 @@
 import type { ContentDocument, Schema } from "./schema/types";
 import type { PreviewConfig } from "./preview";
+import { systemMessage, type Translator } from "./editor/i18n/format";
 
 export function slugify(input: string, existingSlugs: Iterable<string> = []): string {
   const base = input.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
@@ -10,37 +11,37 @@ export function slugify(input: string, existingSlugs: Iterable<string> = []): st
   return slug;
 }
 
-export function normalizeUrlSlug(value: unknown): string {
-  if (typeof value !== "string" || !slugify(value)) throw new Error("URL slug must contain letters or numbers.");
+export function normalizeUrlSlug(value: unknown, message: Translator = systemMessage): string {
+  if (typeof value !== "string" || !slugify(value)) throw new Error(message("validation.slug.required"));
   return slugify(value);
 }
 
-export function effectiveSlug(values: Record<string, unknown>, storageSlug: string): string {
+export function effectiveSlug(values: Record<string, unknown>, storageSlug: string, message: Translator = systemMessage): string {
   if (!Object.hasOwn(values, "slug")) return storageSlug;
-  if (typeof values.slug !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(values.slug)) throw new Error("Invalid URL slug; use lowercase letters, numbers and single dashes.");
+  if (typeof values.slug !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(values.slug)) throw new Error(message("validation.slug.invalid"));
   return values.slug;
 }
 
-export function assertUniqueUrlSlugs(entries: { slug: string; values: Record<string, unknown> }[]): void {
+export function assertUniqueUrlSlugs(entries: { slug: string; values: Record<string, unknown> }[], message: Translator = systemMessage): void {
   const seen = new Set<string>();
   for (const entry of entries) {
-    const slug = effectiveSlug(entry.values, entry.slug);
-    if (seen.has(slug)) throw new Error(`URL slug "${slug}" is already used.`);
+    const slug = effectiveSlug(entry.values, entry.slug, message);
+    if (seen.has(slug)) throw new Error(message("validation.slug.duplicate", { slug }));
     seen.add(slug);
   }
 }
 
-export function validateDocumentSlugs(schema: Schema, documents: ContentDocument[], preview?: PreviewConfig): void {
+export function validateDocumentSlugs(schema: Schema, documents: ContentDocument[], preview?: PreviewConfig, message: Translator = systemMessage): void {
   const seen = new Set<string>();
   const pages = documents.filter(doc => schema.documents.some(type => type.name === doc.type && !type.shared));
-  const fixedRoutes = Object.entries(preview?.pages ?? {}).filter(([key]) => !pages.some(doc => doc.slug === key)).map(([, route]) => route);
+  const fixedRoutes = Object.entries(preview?.pages ?? {}).filter(([key]) => !pages.some(doc => doc.slug === key)).map(([, route]) => typeof route === "string" ? route : route.url);
   for (const doc of documents) {
     const type = schema.documents.find(type => type.name === doc.type);
     if (!type || type.shared) continue;
-    const slug = effectiveSlug(doc.data, doc.slug);
+    const slug = effectiveSlug(doc.data, doc.slug, message);
     const mapping = preview?.documents?.[doc.type];
     const route = mapping ? slug === "home" && mapping.index ? mapping.index : mapping.url.replaceAll("{slug}", slug) : `/${slug}/`;
-    if (seen.has(route) || fixedRoutes.includes(route)) throw new Error(`URL slug "${slug}" is already used.`);
+    if (seen.has(route) || fixedRoutes.includes(route)) throw new Error(message("validation.slug.duplicate", { slug }));
     seen.add(route);
   }
 }