@rigel-cms/rigel 1.0.0 → 1.1.0

package/src/editor/lib/images.ts

@@ -1,13 +1,15 @@
 import { getSettings, setSettings } from "./settings";
+import { translate, locale } from "../i18n";
+import { get } from "svelte/store";
 import { DEFAULT_MAX_FILE_SIZE, mediaMetadata, safeMediaName, storedMediaFile } from "../../media-types";
 import config from "virtual:rigel-config";
 export function getKeys(): StockKeys { return getSettings().apiKeys; }
 export function setKeys(keys: StockKeys) { setSettings({ apiKeys: keys }); }
 
 export const STOCK_PROVIDERS = {
-  pexels: { label: "Pexels", keyURL: "https://www.pexels.com/api/new/", pattern: "[a-zA-Z0-9]{56}", placeholder: "e.g. Ab3dE6fG9hJ2…" },
-  pixabay: { label: "Pixabay", keyURL: "https://pixabay.com/api/docs/#api_key", pattern: "[0-9]+-[a-f0-9]{25}", placeholder: "e.g. 12345678-abcdef012345…" },
-  unsplash: { label: "Unsplash", keyURL: "https://unsplash.com/oauth/applications", pattern: "[a-zA-Z0-9_-]{40,}", placeholder: "e.g. AbCdEf12_GhIjKl34…" },
+  pexels: { label: "Pexels", keyURL: "https://www.pexels.com/api/new/", pattern: "[a-zA-Z0-9]{56}", get placeholder() { return translate("media.pexelsKeyPlaceholder"); } },
+  pixabay: { label: "Pixabay", keyURL: "https://pixabay.com/api/docs/#api_key", pattern: "[0-9]+-[a-f0-9]{25}", get placeholder() { return translate("media.pixabayKeyPlaceholder"); } },
+  unsplash: { label: "Unsplash", keyURL: "https://unsplash.com/oauth/applications", pattern: "[a-zA-Z0-9_-]{40,}", get placeholder() { return translate("media.unsplashKeyPlaceholder"); } },
 } as const;
 
 export type StockSource = "picsum" | keyof typeof STOCK_PROVIDERS;
@@ -43,7 +45,7 @@ export async function unsplash(query: string, key: string): Promise<StockResult[
     query ? `https://api.unsplash.com/search/photos?query=${encodeURIComponent(query)}&per_page=24` : "https://api.unsplash.com/photos?per_page=24",
     { headers: { Authorization: `Client-ID ${key}` } },
   );
-  if (!r.ok) throw new Error(`Unsplash ${r.status}`);
+  if (!r.ok) throw new Error(translate("media.providerStatus", { provider: "Unsplash", status: r.status }));
   const data = await r.json();
   return (query ? data.results ?? [] : data).map((p: Record<string, any>) => ({
     source: "unsplash",
@@ -60,7 +62,7 @@ export async function pexels(query: string, key: string): Promise<StockResult[]>
     query ? `https://api.pexels.com/v1/search?query=${encodeURIComponent(query)}&per_page=24` : "https://api.pexels.com/v1/curated?per_page=24",
     { headers: { Authorization: key } },
   );
-  if (!r.ok) throw new Error(`Pexels ${r.status}`);
+  if (!r.ok) throw new Error(translate("media.providerStatus", { provider: "Pexels", status: r.status }));
   const data = await r.json();
   return (data.photos ?? []).map((p: Record<string, any>) => ({
     source: "pexels",
@@ -79,7 +81,7 @@ export async function pixabay(query: string, key: string): Promise<StockResult[]
   if (query) params.set("q", query);
   else params.set("editors_choice", "true");
   const r = await fetch(`https://pixabay.com/api/?${params}`);
-  if (!r.ok) throw new Error(`Pixabay ${r.status}`);
+  if (!r.ok) throw new Error(translate("media.providerStatus", { provider: "Pixabay", status: r.status }));
   const data = await r.json();
   return (data.hits ?? []).map((p: Record<string, any>) => ({
     source: "pixabay",
@@ -101,18 +103,18 @@ export async function searchImages(
   if (source === "picsum") return picsum(query);
   const keys = getKeys();
   if (source === "pixabay") {
-    if (!keys.pixabay) throw new Error("Add a Pixabay API key in Settings → Media");
+    if (!keys.pixabay) throw new Error(translate("media.pixabayKeyRequired"));
     return pixabay(query, keys.pixabay);
   }
   if (source === "unsplash") {
-    if (!keys.unsplash) throw new Error("Add an Unsplash API key in Settings");
+    if (!keys.unsplash) throw new Error(translate("media.unsplashKeyRequired"));
     return unsplash(query, keys.unsplash);
   }
   if (source === "pexels") {
-    if (!keys.pexels) throw new Error("Add a Pexels API key in Settings → Media");
+    if (!keys.pexels) throw new Error(translate("media.pexelsKeyRequired"));
     return pexels(query, keys.pexels);
   }
-  throw new Error("Unknown stock photo provider");
+  throw new Error(translate("media.unknownStockProvider"));
 }
 
 export async function importStockImage(image: StockResult): Promise<string> {
@@ -122,33 +124,33 @@ export async function importStockImage(image: StockResult): Promise<string> {
     pexels: ["images.pexels.com"], pixabay: ["pixabay.com", "cdn.pixabay.com"],
   };
   if (url.protocol !== "https:" || url.username || url.password || !hosts[image.source]?.includes(url.hostname)) {
-    throw new Error("Unexpected stock photo URL");
+    throw new Error(translate("media.unexpectedStockUrl"));
   }
   if (image.source === "unsplash") {
     const key = getKeys().unsplash;
-    if (!key || !image.id) throw new Error("Unsplash photo or API key is missing");
+    if (!key || !image.id) throw new Error(translate("media.unsplashPhotoMissing"));
     const tracked = await fetch(`https://api.unsplash.com/photos/${encodeURIComponent(image.id)}/download`, {
       headers: { Authorization: "Client-" + "ID " + key },
     });
-    if (!tracked.ok) throw new Error(`Unsplash download tracking failed (${tracked.status})`);
+    if (!tracked.ok) throw new Error(translate("media.unsplashTrackingFailed", { status: tracked.status }));
     return image.url;
   }
   return importImageUrl(image.url);
 }
 
 export async function importImageUrl(value: string): Promise<string> {
-  if (!safeImageUrl(value)) throw new Error("Unsafe image URL");
-  if (!value.startsWith("/") && new URL(value).protocol !== "https:") throw new Error("Remote imports require HTTPS");
-  if (!value.startsWith("/") && new URL(value).hostname === "images.unsplash.com") throw new Error("Unsplash API images must stay hotlinked. Use Unsplash in the content image picker.");
+  if (!safeImageUrl(value)) throw new Error(translate("media.unsafeImageUrl"));
+  if (!value.startsWith("/") && new URL(value).protocol !== "https:") throw new Error(translate("media.remoteRequiresHttps"));
+  if (!value.startsWith("/") && new URL(value).hostname === "images.unsplash.com") throw new Error(translate("media.unsplashHotlinkRequired"));
   let response: Response;
   try { response = await fetch(value, { credentials: "omit", referrerPolicy: "no-referrer" }); }
-  catch { throw new Error("Image download failed. The source must allow browser downloads (CORS); alternatively upload the image file."); }
-  if (!response.ok) throw new Error(`Photo download failed (${response.status})`);
+  catch { throw new Error(translate("media.imageDownloadFailed")); }
+  if (!response.ok) throw new Error(translate("media.photoDownloadFailed", { status: response.status }));
   const limit = config.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
-  if (Number(response.headers.get("Content-Length")) > limit) throw new Error(`Photo exceeds the ${limit / 1024 / 1024} MB import limit`);
+  if (Number(response.headers.get("Content-Length")) > limit) throw new Error(translate("media.photoLimitExceeded", { limit: limit / 1024 / 1024 }));
   const type = response.headers.get("Content-Type")?.split(";")[0].trim().toLowerCase();
-  if (!["image/jpeg", "image/png", "image/webp"].includes(type ?? "")) throw new Error("Choose a JPEG, PNG or WebP image.");
-  if (!response.body) throw new Error("Empty image download");
+  if (!["image/jpeg", "image/png", "image/webp"].includes(type ?? "")) throw new Error(translate("media.chooseImageFormat"));
+  if (!response.body) throw new Error(translate("media.emptyDownload"));
   const reader = response.body.getReader();
   const chunks: Uint8Array<ArrayBuffer>[] = [];
   let size = 0;
@@ -157,7 +159,7 @@ export async function importImageUrl(value: string): Promise<string> {
       const { done, value: chunk } = await reader.read();
       if (done) break;
       size += chunk.byteLength;
-      if (size > limit) { await reader.cancel(); throw new Error(`Photo exceeds the ${limit / 1024 / 1024} MB import limit`); }
+      if (size > limit) { await reader.cancel(); throw new Error(translate("media.photoLimitExceeded", { limit: limit / 1024 / 1024 })); }
       chunks.push(new Uint8Array(chunk));
     }
   } finally { reader.releaseLock(); }
@@ -185,23 +187,23 @@ export function currentAuthor(): string {
 export async function uploadMedia(file: File): Promise<string> {
   const metadata = mediaMetadata(file.name);
   const limit = config.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
-  if (!safeMediaName(file.name) || !metadata || file.size > limit) throw new Error(`Choose a supported file up to ${limit / 1024 / 1024} MB with a safe filename.`);
-  const response = await fetch("/rigel/api/local/media", { method: "POST", headers: { "Content-Type": metadata.type, "X-Rigel-Filename": file.name, "X-Rigel-Author": currentAuthor() }, body: file });
-  if (!response.ok) throw new Error(`Upload failed (${response.status}): ${await response.text()}`);
+  if (!safeMediaName(file.name) || !metadata || file.size > limit) throw new Error(translate("media.chooseSupportedFile", { limit: limit / 1024 / 1024 }));
+  const response = await fetch("/rigel/api/local/media", { method: "POST", headers: { "Content-Type": metadata.type, "Accept-Language": get(locale), "X-Rigel-Filename": file.name, "X-Rigel-Author": currentAuthor() }, body: file });
+  if (!response.ok) throw new Error(translate("media.uploadFailed", { status: response.status, body: await response.text() }));
   const result = await response.json();
-  if (typeof result.url !== "string" || !safeImageUrl(result.url) || !result.url.startsWith("/") || !storedMediaFile.test(result.url.split("/").pop() ?? "") || !mediaMetadata(result.url)) throw new Error("Invalid uploaded asset URL");
+  if (typeof result.url !== "string" || !safeImageUrl(result.url) || !result.url.startsWith("/") || !storedMediaFile.test(result.url.split("/").pop() ?? "") || !mediaMetadata(result.url)) throw new Error(translate("media.invalidUploadedUrl"));
   return result.url;
 }
 
 export async function uploadImage(blob: Blob): Promise<string> {
   const limit = config.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
-  if (blob.size > limit) throw new Error(`Photo exceeds the ${limit / 1024 / 1024} MB import limit`);
-  const saved = await fetch("/rigel/api/local/media", { method: "POST", body: blob });
-  if (saved.status === 404) throw new Error("Photo import requires the local dev server");
-  if (!saved.ok) throw new Error(`Photo import failed (${saved.status})`);
+  if (blob.size > limit) throw new Error(translate("media.photoLimitExceeded", { limit: limit / 1024 / 1024 }));
+  const saved = await fetch("/rigel/api/local/media", { method: "POST", headers: { "Accept-Language": get(locale) }, body: blob });
+  if (saved.status === 404) throw new Error(translate("media.localImportRequired"));
+  if (!saved.ok) throw new Error(translate("media.photoImportFailedStatus", { status: saved.status }));
   const result = await saved.json();
   if (typeof result.url !== "string" || !safeImageUrl(result.url) || !result.url.startsWith("/") || !storedMediaFile.test(result.url.split("/").pop() ?? "") || !/\.(jpg|png|webp)$/.test(result.url)) {
-    throw new Error("Invalid imported photo URL");
+    throw new Error(translate("media.invalidImportedUrl"));
   }
   return result.url;
 }

package/src/editor/lib/menu-tree.ts

@@ -1,4 +1,5 @@
 import type { MenuItem } from "../../manifest/menu";
+import { translate } from "../i18n";
 
 export function menuRows(items: MenuItem[], parentId: string | null = null, depth = 1): { item: MenuItem; parentId: string | null; depth: number; previous?: string; next?: string }[] {
   return items.flatMap((item, index) => [
@@ -16,8 +17,8 @@ export function editMenuItem(items: MenuItem[], id: string, update: (item: MenuI
 
 export function moveMenuItem(items: MenuItem[], id: string, targetId: string | null, position: "before" | "after" | "inside", maxDepth: number): MenuItem[] {
   const source = menuRows(items).find((row) => row.item.id === id)?.item;
-  if (!source) throw new Error("Menu item not found");
-  if (targetId && menuRows([source]).some((row) => row.item.id === targetId)) throw new Error("An item cannot be moved into itself or its children");
+  if (!source) throw new Error(translate("fields.menuItemNotFound"));
+  if (targetId && menuRows([source]).some((row) => row.item.id === targetId)) throw new Error(translate("fields.menuMoveIntoSelf"));
   const next = editMenuItem(items, id, () => null);
   let found = targetId === null;
   function insert(list: MenuItem[]): MenuItem[] {
@@ -31,7 +32,7 @@ export function moveMenuItem(items: MenuItem[], id: string, targetId: string | n
     });
   }
   const result = targetId === null ? [...next, source] : insert(next);
-  if (!found) throw new Error("Drop target no longer exists");
-  if (menuRows(result).some((row) => row.depth > maxDepth)) throw new Error(`This move exceeds the ${maxDepth}-level limit`);
+  if (!found) throw new Error(translate("fields.menuDropTargetMissing"));
+  if (menuRows(result).some((row) => row.depth > maxDepth)) throw new Error(translate("fields.menuMoveDepthLimit", { maxDepth }));
   return result;
 }

package/src/editor/lib/preview-frame.ts

@@ -1,3 +1,4 @@
+import { translate } from "../i18n";
 import DOMPurify from "dompurify";
 
 export async function fetchPreview(url: URL, signal: AbortSignal): Promise<string> {
@@ -5,10 +6,10 @@ export async function fetchPreview(url: URL, signal: AbortSignal): Promise<strin
   try {
     response = await fetch(url, { mode: "cors", credentials: "omit", referrerPolicy: "no-referrer", redirect: "error", signal: AbortSignal.any([signal, AbortSignal.timeout(15000)]) });
   } catch {
-    throw new Error("Draft preview could not be fetched. Check the URL, HTTPS, CORS (Access-Control-Allow-Origin for this editor), redirects and the editor’s connect-src policy. Authentication cookies are not sent.");
+    throw new Error(translate("richtext.previewFetchError"));
   }
-  if (!response.ok) throw new Error(`Draft preview returned HTTP ${response.status}. Check the draft deployment and mapped route.`);
-  if (!response.headers.get("content-type")?.toLowerCase().includes("text/html")) throw new Error("Draft preview did not return HTML. Check the mapped route and Content-Type header.");
+  if (!response.ok) throw new Error(translate("richtext.previewHttpError", { status: response.status }));
+  if (!response.headers.get("content-type")?.toLowerCase().includes("text/html")) throw new Error(translate("richtext.previewHtmlError"));
   const root = DOMPurify.sanitize(await response.text(), {
     WHOLE_DOCUMENT: true,
     RETURN_DOM: true,

package/src/editor/lib/schema-edit.ts

@@ -1,4 +1,5 @@
 import { cloneJson, newKey, regenerateKeys, setPath } from "../../schema/paths";
+import { translate } from "../i18n";
 import { isPlainObject, objectDef } from "../../schema/validate";
 import type { ContentDocument, DocumentDef, FieldDef, Schema } from "../../schema/types";
 
@@ -16,8 +17,8 @@ export function sectionTypeDef(schema: Schema, type: unknown) {
   return schema.objects.find((object) => object.name === type && object.type === "section");
 }
 
-export function sectionLabel(schema: Schema, type: unknown): string {
-  return sectionTypeDef(schema, type)?.title ?? String(type ?? "Section");
+export function sectionLabel(schema: Schema, type: unknown, fallback = translate("fields.section")): string {
+  return sectionTypeDef(schema, type)?.title ?? String(type ?? fallback);
 }
 
 export function fieldForPath(schema: Schema, docType: DocumentDef, values: Record<string, unknown>, path: string): FieldDef | null {

package/src/editor/lib/settings.ts

@@ -1,5 +1,6 @@
 import { readStorage, writeStorage } from "./storage";
 import type { StockKeys } from "./images";
+import { availableLocales, setLocale, type Locale } from "../i18n";
 
 export interface RigelUserPref {
   sidebarCollapsed?: boolean;
@@ -10,7 +11,7 @@ export interface RigelUserPref {
 
 export interface RigelSettings {
   theme: "system" | "light" | "dark";
-  language: "en" | "es" | "ru";
+  language: Locale;
 
   devMode: boolean;
   highContrast: boolean;
@@ -19,7 +20,7 @@ export interface RigelSettings {
   userPref: RigelUserPref;
 }
 
-const prefs = (theme: "system" | "light" | "dark" = "system", language: "en" | "es" | "ru" = "en"): Pick<RigelSettings, "theme" | "language" | "devMode" | "highContrast"> => ({
+const prefs = (theme: "system" | "light" | "dark" = "system", language: Locale = "en"): Pick<RigelSettings, "theme" | "language" | "devMode" | "highContrast"> => ({
   theme, language, devMode: false, highContrast: false,
 });
 
@@ -40,7 +41,7 @@ export function getSettings(): RigelSettings {
     const legacyPref = readLegacyPref();
     return {
       theme: ["system", "light", "dark"].includes(saved?.theme) ? saved.theme : DEFAULTS.theme,
-      language: ["en", "es", "ru"].includes(saved?.language) ? saved.language : DEFAULTS.language,
+      language: availableLocales.includes(saved?.language) ? saved.language : DEFAULTS.language,
       devMode: typeof saved?.devMode === "boolean" ? saved.devMode : DEFAULTS.devMode,
       highContrast: typeof saved?.highContrast === "boolean" ? saved.highContrast : DEFAULTS.highContrast,
       apiKeys: mergedKeys,
@@ -83,6 +84,7 @@ function readLegacyPref(): Partial<RigelUserPref> {
 export function setSettings(s: Partial<RigelSettings>) {
   const next = { ...getSettings(), ...s, userPref: { ...getSettings().userPref, ...s.userPref } };
   writeStorage("settings", next);
+  setLocale(next.language);
   clearLegacy();
   localStorage.removeItem("rigel.user");
 }

package/src/editor/lib/slash-command.ts

@@ -0,0 +1 @@
+export const slashCommand = /^\/([\p{L}\p{M}\p{N}_ ]*)$/u;

package/src/editor/lib/tooltip.ts

@@ -100,7 +100,7 @@ function createTooltips() {
       if (event.pointerType === "touch") return;
       if (event.target === tip) { clearTimeout(timer); return; }
       const element = target(event);
-      if (!element || element.contains(event.relatedTarget as Node | null) || element === anchor || element === doc.activeElement) return;
+      if (!element || element.contains(event.relatedTarget as Node | null) || element === anchor) return;
       hide(); timer = setTimeout(() => show(element), 450);
     };
     const out = (event: PointerEvent) => {

package/src/editor/main.ts

@@ -1,9 +1,18 @@
 import { mount } from "svelte";
+import { get } from "svelte/store";
+import { locale, setLocale, t } from "./i18n";
+import { getSettings } from "./lib/settings";
 import App from "./App.svelte";
 import "./styles.css";
 
 const target = document.getElementById("rigel");
 if (target) {
+  setLocale(getSettings().language);
+  const unsubscribe = t.subscribe(message => {
+    document.documentElement.lang = get(locale);
+    document.title = message("system.editorTitle");
+  });
+  import.meta.hot?.dispose(unsubscribe);
   import.meta.hot?.send("rigel:editor-ready");
   mount(App, { target });
 }

package/src/editor/styles.css

@@ -986,7 +986,7 @@
 .rigel .settings-nav button:hover { background: var(--surface-raised); color: var(--text); }
 .rigel .settings-nav button.active { background: var(--accent-soft); color: var(--on-accent-soft); font-weight: 600; }
 .rigel .settings-nav .pico { width: 24px; flex-shrink: 0; }
-.rigel .settings-pane { padding: 1.25rem 1.5rem 1.25rem; }
+.rigel .settings-pane { min-width: 0; overflow-wrap: anywhere; padding: 1.25rem 1.5rem 1.25rem; }
 .rigel .settings-pane h3 {
   font-size: 0.875rem; font-weight: 600; text-transform: none;
   letter-spacing: 0; color: var(--text); margin: 0 0 0.75rem;
@@ -1231,8 +1231,11 @@
 .rigel .block-menu { position: fixed; inset: auto; margin: 0; }
 .rigel .block-slash { position: fixed; inset: auto; margin: 0; }
 .rigel .block-markdown { margin: 0; padding: 1rem; overflow: auto; white-space: pre-wrap; font: 0.8125rem/1.7 ui-monospace, monospace; }
-.rigel :is(.block-menu, .block-slash) > button { display: block; width: 100%; text-align: left; padding: 0.5rem; background: var(--panel); border: 0; color: var(--text); font: inherit; font-size: 0.8125rem; cursor: pointer; }
-.rigel :is(.block-menu, .block-slash) > button:is(:hover,[aria-selected=true]) { background: var(--accent-soft); color: var(--on-accent-soft); }
+.rigel :is(.block-menu, .block-slash) > button, .rigel .extension-group-menu [data-rigel-command] button { display: block; width: 100%; text-align: left; padding: 0.5rem; background: var(--panel); border: 0; color: var(--text); font: inherit; font-size: 0.8125rem; cursor: pointer; }
+.rigel :is(.block-menu, .block-slash) > button:is(:hover,[aria-selected=true]), .rigel .extension-group-menu button:hover:not(:disabled) { background: var(--accent-soft); color: var(--on-accent-soft); }
+.rigel .extension-group-trigger, .rigel .extension-group-menu > span { display: contents; }
+.rigel .body-toolbar :where([data-rigel-command], [data-rigel-group]) button { display: inline-flex; align-items: center; justify-content: center; min-width: 32px; height: 32px; padding: 0 0.5rem; gap: 0.25rem; background: transparent; color: var(--text); border: 0; font: inherit; cursor: pointer; }
+.rigel .body-toolbar :where([data-rigel-command], [data-rigel-group]) button:hover:not(:disabled) { background: var(--surface-raised); }
 .rigel .block-format-menu > button { display: flex; align-items: center; gap: 0.75rem; }
 .rigel .block-format-menu > button > span { flex: 1; }
 .rigel .block-format-menu > button[aria-checked=true] { background: var(--accent-soft); color: var(--on-accent-soft); }

package/src/env.d.ts

@@ -1,3 +1,13 @@
+declare module "virtual:rigel-extensions" {
+  const extensions: import("./extensions").RigelExtension[];
+  export default extensions;
+}
+
+declare module "virtual:rigel-i18n" {
+  const dictionaries: import("./editor/i18n/format").Dictionaries;
+  export default dictionaries;
+}
+
 declare module "virtual:rigel-manifest" {
   import type { CopyPage, ManifestCollection } from "@rigel-cms/rigel/content";
   export const pages: CopyPage[];
@@ -17,6 +27,6 @@ declare module "virtual:rigel-content" {
 
 declare module "virtual:rigel-config" {
   import type { RigelConfig } from "@rigel-cms/rigel";
-  const config: Pick<RigelConfig, "copyDir" | "backend" | "jsonOutput" | "demo" | "collections" | "menus" | "mediaDir" | "maxFileSize" | "schema" | "preview"> & { publicDir?: string; root?: string };
+  const config: Pick<RigelConfig, "copyDir" | "backend" | "jsonOutput" | "demo" | "languages" | "collections" | "menus" | "mediaDir" | "maxFileSize" | "schema" | "preview"> & { publicDir?: string; root?: string };
   export default config;
 }

package/src/extensions.ts

@@ -0,0 +1,160 @@
+import type { Component } from "svelte";
+
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+export type BlockData = { [key: string]: JsonValue };
+
+export interface ExtensionSelection {
+  text: string;
+  blockType: string;
+  block?: { name: string; data: BlockData };
+}
+
+export interface ExtensionContext {
+  readonly selection: ExtensionSelection;
+  insertText(text: string): void;
+  insertBlock(name: string, data: BlockData): void;
+  updateBlock(data: BlockData): void;
+}
+
+export interface ExtensionButtonProps {
+  label: string;
+  disabled: boolean;
+  onclick: () => void;
+}
+
+export interface ExtensionBlockProps {
+  data: BlockData;
+  onchange: (data: BlockData) => void;
+}
+
+export interface ExtensionCommand {
+  name: string;
+  label: string;
+  slash?: string;
+  toolbar?: boolean;
+  group?: string;
+  button?: Component<ExtensionButtonProps>;
+  run: (context: ExtensionContext) => void | Promise<void>;
+}
+
+export interface ExtensionBlock {
+  name: string;
+  label: string;
+  editor: Component<ExtensionBlockProps>;
+  render: Component<{ data: BlockData }>;
+  validate: (data: BlockData) => void;
+  toMarkdown?: (data: BlockData) => string;
+}
+
+export interface RigelExtension {
+  name: string;
+  commands?: ExtensionCommand[];
+  blocks?: ExtensionBlock[];
+  groups?: ExtensionGroup[];
+}
+
+export function defineExtension<T extends RigelExtension>(extension: T): T {
+  return extension;
+}
+
+const forbiddenKeys = new Set(["__proto__", "constructor", "prototype"]);
+const builtins = new Set(["paragraph", "h1", "h2", "h3", "h4", "h5", "h6", "quote", "bullet", "number", "code", "image", "divider", "table", "video", "youtube", "vimeo", "bold", "italic", "underline", "strikethrough", "subscript", "superscript", "highlight", "link", "undo", "redo", "clear", "clear-formatting"]);
+
+export function validateExtensionName(value: unknown): asserts value is string {
+  if (typeof value !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(value) || forbiddenKeys.has(value)) throw new Error("rigel: invalid extension identifier");
+}
+
+function plainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+
+function objectShape(value: unknown, required: string[], optional: string[] = []): asserts value is Record<string, unknown> {
+  if (!plainObject(value) || required.some(key => !Object.hasOwn(value, key))) throw new Error("rigel: invalid extension object");
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key)!;
+    if (typeof key !== "string" || ![...required, ...optional].includes(key) || !descriptor.enumerable || !Object.hasOwn(descriptor, "value")) throw new Error("rigel: invalid extension property");
+  }
+}
+
+export function validateBlockData(value: unknown): asserts value is BlockData {
+  if (!plainObject(value)) throw new Error("rigel: extension data must be a plain JSON object");
+  let nodes = 0;
+  const ancestors = new Set<object>();
+  function check(item: unknown, depth: number) {
+    if (++nodes > 10000 || depth > 16) throw new Error("rigel: extension data exceeds depth or node limit");
+    if (item === null || typeof item === "string" || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)) return;
+    if (typeof item !== "object" || !item || (!Array.isArray(item) && !plainObject(item)) || ancestors.has(item)) throw new Error("rigel: extension data must be finite plain JSON without cycles");
+    ancestors.add(item);
+    const array = Array.isArray(item);
+    if (array && Object.getPrototypeOf(item) !== Array.prototype) throw new Error("rigel: extension data must contain plain JSON arrays");
+    if (array && item.length > 10000) throw new Error("rigel: extension data exceeds node limit");
+    const keys = Reflect.ownKeys(item);
+    if (array && keys.length !== item.length + 1) throw new Error("rigel: extension data contains a sparse or decorated array");
+    for (const key of keys) {
+      if (array && key === "length") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(item, key)!;
+      if (typeof key !== "string" || forbiddenKeys.has(key) || !descriptor.enumerable || !Object.hasOwn(descriptor, "value") || array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= item.length)) throw new Error("rigel: extension data contains a non-JSON property");
+      check(descriptor.value, depth + 1);
+    }
+    ancestors.delete(item);
+  }
+  check(value, 0);
+  if (new TextEncoder().encode(JSON.stringify(value)).length > 100000) throw new Error("rigel: extension data exceeds 100000 UTF-8 bytes");
+}
+
+export interface ExtensionGroup {
+  name: string;
+  label: string;
+  button?: Component<ExtensionButtonProps>;
+}
+
+export function resolveExtensions(modules: RigelExtension[]): { commands: ExtensionCommand[]; blocks: ExtensionBlock[]; groups: ExtensionGroup[] } {
+  if (!Array.isArray(modules)) throw new Error("rigel: extensions must be an array");
+  const commands: ExtensionCommand[] = [], blocks: ExtensionBlock[] = [], groups: ExtensionGroup[] = [];
+  const modulesSeen = new Set<string>(), names = new Set<string>(), slashes = new Set<string>(), groupNames = new Set<string>();
+  function unique(name: unknown, seen: Set<string>, builtin = false) {
+    validateExtensionName(name);
+    if (seen.has(name) || builtin && builtins.has(name)) throw new Error(`rigel: duplicate or reserved extension name: ${name}`);
+    seen.add(name);
+  }
+  for (const module of modules) {
+    objectShape(module, ["name"], ["commands", "blocks", "groups"]);
+    unique(module.name, modulesSeen);
+    for (const kind of ["commands", "blocks", "groups"] as const) {
+      if (!Object.hasOwn(module, kind)) continue;
+      const entries = module[kind];
+      if (!Array.isArray(entries)) throw new Error(`rigel: extension ${kind} must be an array`);
+      for (const entry of entries) {
+        objectShape(entry, kind === "commands" ? ["name", "label", "run"] : kind === "blocks" ? ["name", "label", "editor", "render", "validate"] : ["name", "label"], kind === "commands" ? ["slash", "toolbar", "button", "group"] : kind === "blocks" ? ["toMarkdown"] : ["button"]);
+        unique(entry.name, kind === "groups" ? groupNames : names, kind !== "groups");
+        if (typeof entry.label !== "string" || !entry.label.trim()) throw new Error("rigel: extension label is required");
+        for (const key of kind === "commands" ? ["run", "button"] : kind === "blocks" ? ["editor", "render", "validate", "toMarkdown"] : ["button"]) {
+          if (Object.hasOwn(entry, key) && typeof entry[key] !== "function") throw new Error(`rigel: extension ${key} must be a function/component`);
+        }
+        if (kind === "commands") {
+          if (Object.hasOwn(entry, "toolbar") && typeof entry.toolbar !== "boolean") throw new Error("rigel: extension toolbar must be boolean");
+          if (Object.hasOwn(entry, "slash")) unique(entry.slash, slashes, true);
+          if (Object.hasOwn(entry, "group")) validateExtensionName(entry.group);
+          commands.push(entry as unknown as ExtensionCommand);
+        } else if (kind === "blocks") blocks.push(entry as unknown as ExtensionBlock);
+        else groups.push(entry as unknown as ExtensionGroup);
+      }
+    }
+  }
+  for (const command of commands) {
+    if (command.group !== undefined && !groupNames.has(command.group)) throw new Error(`rigel: unknown extension group: ${command.group}`);
+  }
+  return { commands, blocks, groups };
+}
+
+export function validateExtensionBlocks(body: unknown, blocks: ExtensionBlock[]): void {
+  const children = (body as { root?: { children?: unknown[] } } | null)?.root?.children;
+  if (!Array.isArray(children)) return;
+  for (const raw of children) {
+    if (!raw || typeof raw !== "object" || (raw as { type?: unknown }).type !== "extension") continue;
+    const node = raw as { name: string; data: unknown };
+    validateExtensionName(node.name);
+    validateBlockData(node.data);
+    blocks.find(block => block.name === node.name)?.validate(node.data);
+  }
+}

package/src/manifest/collections.ts

@@ -1,6 +1,7 @@
 import type { CollectionField } from "./types";
 import type { ContentDocument } from "../schema/types";
 import { validateCollectionReferences } from "./references";
+import { systemMessage, type Translator } from "../editor/i18n/format";
 
 export function initialCollectionValues(fields: CollectionField[], title: string): Record<string, unknown> {
   return Object.fromEntries(fields.map(field => [field.key,
@@ -11,17 +12,17 @@ export function initialCollectionValues(fields: CollectionField[], title: string
   ]));
 }
 
-export function validateCollectionValues(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[] = []): void {
-  if (!values || typeof values !== "object" || Array.isArray(values)) throw new Error("Invalid article frontmatter");
+export function validateCollectionValues(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[] = [], message: Translator = systemMessage): void {
+  if (!values || typeof values !== "object" || Array.isArray(values)) throw new Error(message("validation.collection.invalid"));
   for (const field of fields) {
     const value = values[field.key];
-    if (field.required && (value === undefined || value === null || (typeof value === "string" && !value.trim()) || (Array.isArray(value) && !value.length))) throw new Error(`${field.label}: required`);
+    if (field.required && (value === undefined || value === null || (typeof value === "string" && !value.trim()) || (Array.isArray(value) && !value.length))) throw new Error(message("validation.collection.required", { label: field.label }));
     if (value === undefined || field.type === "reference") continue;
     const valid = field.type === "boolean" ? typeof value === "boolean" :
       field.type === "tags" ? Array.isArray(value) && value.every(tag => typeof tag === "string") :
       field.type === "date" ? typeof value === "string" && (value === "" || (/^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value)) :
       typeof value === "string";
-    if (!valid) throw new Error(`${field.label}: expected ${field.type}`);
+    if (!valid) throw new Error(message("validation.collection.expected", { label: field.label, type: field.type }));
   }
-  validateCollectionReferences(fields, values, documents);
+  validateCollectionReferences(fields, values, documents, message);
 }

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