@rigel-cms/rigel 1.0.0 → 1.2.0

package/README.md

@@ -22,6 +22,14 @@ Use the [Astro starter](https://github.com/rigel-cms/rigel-starter), or follow t
 
 [Documentation](https://rigelcms.dev/docs/) · [Content model](https://rigelcms.dev/docs/content-model/) · [Previews](https://rigelcms.dev/docs/preview/) · [GitHub setup](https://rigelcms.dev/docs/github-publishing/)
 
+## Content languages
+
+Declare language-specific page types and article collections, then use an optional content-language selector in the editor. See [Content languages](docs/content-locales.md) for configuration. Website routing stays in your Astro templates.
+
+## Extensions
+
+Register your own slash commands, toolbar buttons and saved article blocks with Svelte components. The [extension guide](docs/extensions.md) covers registration, editable blocks and published rendering.
+
 ## License
 
 [Apache-2.0](LICENSE). Copyright 2026 [Alex Zappa](https://alex.zappa.dev/) ([FreshJuice](https://freshjuice.dev/)).

package/docs/content-locales.md

@@ -0,0 +1,53 @@
+# Content languages
+
+Content languages are optional. Configure them separately from `languages`, which selects the editor's interface translations.
+
+```js
+rigel({
+  contentLocales: {
+    defaultLocale: "en",
+    locales: [
+      { code: "en", label: "English" },
+      { code: "fr", label: "Français" },
+    ],
+  },
+  schema,
+  collections: [
+    { name: "blogEn", label: "Blog", locale: "en", folder: "src/content/blog/en", fields },
+    { name: "blogFr", label: "Articles", locale: "fr", folder: "src/content/blog/fr", fields },
+  ],
+  preview: {
+    documents: {
+      pageEn: { url: "/en/{slug}/" },
+      pageFr: { url: "/fr/{slug}/" },
+    },
+    collections: {
+      blogEn: { url: "/en/blog/{slug}/", new: "/preview/blog-en/" },
+      blogFr: { url: "/fr/blog/{slug}/", new: "/preview/blog-fr/" },
+    },
+  },
+});
+```
+
+Here `schema` and `fields` are your existing document schema and article fields. Add `locale` to each document type that belongs to one content language:
+
+```ts
+defineDocument({
+  name: "pageFr",
+  title: "Pages françaises",
+  type: "document",
+  locale: "fr",
+  folder: "src/content/pages/fr",
+  fields: pageFields,
+});
+```
+
+Each type can have different fields, allowed sections and initial content. You can also annotate an existing `defineCopy` page with `locale`. Rigel reads the annotation, not the folder name.
+
+With multiple configured locales, the editor shows a Content language dropdown. It filters navigation, page lists, collections and search. Switching away from unsaved changes offers the existing Save, Discard and Keep editing choices. New sessions start with `defaultLocale`.
+
+Content without a `locale` remains visible in every language. Use this for common authors, media and other shared records. A shared document type can also have a locale when its records are language-specific. The language filter is an editing convenience, not an access-control boundary: the manifest and publishing batch still contain the site's complete content.
+
+Without `contentLocales`, the editor keeps its existing navigation and shows no content-language dropdown. A single configured locale also needs no dropdown.
+
+Your Astro routes and templates still own website localization, including public language links, HTML `lang`, translated navigation and fallback behavior. Rigel does not translate text, pair translated entries or generate localized routes. Keep each type's URL mapping consistent with the website routes, and prepare its preview bindings as usual.

package/docs/extensions.md

@@ -0,0 +1,194 @@
+# Extensions
+
+Extensions are developer-owned TypeScript modules selected in your Astro configuration. Rigel imports them at build time. Restart the dev server after changing the extension list.
+
+Install `@astrojs/svelte` in your site to let `astro check` typecheck your Svelte components. Rigel already registers the Svelte compiler for the editor and extension modules.
+
+```ts
+import { defineConfig } from 'astro/config';
+import { rigel } from '@rigel-cms/rigel';
+
+export default defineConfig({
+  integrations: [rigel({ extensions: ['./src/rigel/cta.ts'] })],
+});
+```
+
+## Add a call-to-action block
+
+Create `src/rigel/cta.ts`:
+
+```ts
+import { defineExtension } from '@rigel-cms/rigel/extensions';
+import CtaEditor from './CtaEditor.svelte';
+import Cta from './Cta.svelte';
+import CtaButton from './CtaButton.svelte';
+
+export default defineExtension({
+  name: 'site-cta',
+  commands: [{
+    name: 'insert-cta',
+    label: 'Call to action',
+    slash: 'cta',
+    toolbar: true,
+    button: CtaButton,
+    run(context) {
+      context.insertBlock('cta', { label: 'Contact us', href: '/contact/' });
+    },
+  }],
+  blocks: [{
+    name: 'cta',
+    label: 'Call to action',
+    editor: CtaEditor,
+    render: Cta,
+    validate(data) {
+      if (typeof data.label !== 'string' || !data.label.trim()) {
+        throw new Error('Enter a button label.');
+      }
+      if (typeof data.href !== 'string' || !/^\/[a-z0-9/-]*$/.test(data.href)) {
+        throw new Error('Choose a local path such as /contact/.');
+      }
+    },
+    toMarkdown(data) {
+      const label = String(data.label).replace(/[\\[\]]/g, '\\$&');
+      return `[${label}](<${data.href}>)`;
+    },
+  }],
+});
+```
+
+Create `src/rigel/CtaEditor.svelte`:
+
+```svelte
+<script lang="ts">
+  import type { ExtensionBlockProps } from '@rigel-cms/rigel/extensions';
+  let { data, onchange }: ExtensionBlockProps = $props();
+</script>
+
+<label>
+  Label
+  <input
+    value={String(data.label ?? '')}
+    oninput={(event) => onchange({ ...data, label: event.currentTarget.value })}
+  />
+</label>
+<label>
+  Local path
+  <input
+    value={String(data.href ?? '')}
+    oninput={(event) => onchange({ ...data, href: event.currentTarget.value })}
+  />
+</label>
+```
+
+Call `onchange` with the complete next data object rather than mutating `data`. Changes stay in the draft until the author clicks Save. Keep temporary input state inside your component if an incomplete value cannot pass your validator.
+
+Create `src/rigel/Cta.svelte` for published HTML and read-only previews:
+
+```svelte
+<script lang="ts">
+  import type { BlockData } from '@rigel-cms/rigel/extensions';
+  let { data }: { data: BlockData } = $props();
+</script>
+
+<aside class="cta">
+  <a href={String(data.href)}>{data.label}</a>
+</aside>
+
+<style>
+  .cta { padding: 1rem; border: 1px solid currentColor; }
+</style>
+```
+
+Create `src/rigel/CtaButton.svelte` to supply the command's toolbar button:
+
+```svelte
+<script lang="ts">
+  import type { ExtensionButtonProps } from '@rigel-cms/rigel/extensions';
+  let { label, disabled, onclick }: ExtensionButtonProps = $props();
+</script>
+
+<button type="button" {disabled} {onclick} data-tooltip={label} aria-label={label} onpointerdown={(event) => event.preventDefault()}>
+  CTA
+</button>
+```
+
+Omit `button` to use Rigel's default toolbar button. `slash: 'cta'` exposes the same command as `/cta`. Names must be unique across the selected extensions. Commands can read `context.selection`, call `insertText(text)`, insert a registered block with `insertBlock(name, data)`, or replace a selected custom block's data with `updateBlock(data)`.
+
+## Group toolbar actions
+
+Register a group and assign commands to it by name:
+
+```ts
+export default defineExtension({
+  name: 'widgets',
+  groups: [{ name: 'widgets', label: 'Widgets', button: WidgetsButton }],
+  commands: [{
+    name: 'insert-callout',
+    label: 'Insert callout',
+    slash: 'callout',
+    group: 'widgets',
+    run: context => context.insertBlock('callout', {
+      title: 'Good to know', message: 'A note for readers.', tone: 'info',
+    }),
+  }],
+  blocks: [{
+    name: 'callout',
+    label: 'Callout',
+    editor: CalloutEditor,
+    render: Callout,
+    validate(data) {
+      if (typeof data.title !== 'string' || typeof data.message !== 'string' || data.tone !== 'info') {
+        throw new Error('Expected a title, message and info tone.');
+      }
+    },
+  }],
+});
+```
+
+The group occupies one toolbar button. Opening it shows only its assigned commands. A command's slash shortcut still works independently. Grouped commands appear in the toolbar automatically; set `toolbar: false` to keep a command out of the menu. Commands without a group keep their existing behavior.
+
+A group's optional `button` uses the same `ExtensionButtonProps` as a command button. It can contain an SVG icon instead of text; keep its accessible label and call `onclick` to toggle the menu. Omit `button` for Rigel's default group trigger. Group names must be unique across registered modules. Commands can reference a group declared by another registered module, regardless of module order. An unknown group name is a configuration error. Empty groups do not create toolbar buttons.
+
+The starter's `src/rigel/widgets.ts` is a complete second example: an icon-only Widgets group with callout and warning actions, an editable callout component, validation and a published renderer. The original CTA example remains a standalone button.
+
+## Render articles on your site
+
+Use the public article entry in Astro pages:
+
+```astro
+---
+import { renderArticle, articleMarkdown } from '@rigel-cms/rigel/article';
+const { body } = Astro.props;
+let head = '';
+const html = renderArticle(body, { onHead: value => { head = value; } });
+const markdown = articleMarkdown(body);
+---
+
+<html lang="en">
+  <head><Fragment set:html={head} /></head>
+  <body><article data-rigel-richtext="$body" set:html={html} /></body>
+</html>
+```
+
+`renderArticle(body)` still returns an HTML string. It validates each registered custom block and server-renders its `render` component with Svelte. By default the returned string includes component head output, including CSS emitted by Svelte. Use `onHead` to put that output in your page's head instead. CSS extracted by the build remains the build tool's responsibility. Keep render components synchronous for this string-returning API.
+
+`renderArticle(body, { preview: true })` returns escaped custom-block markers. Rigel sanitizes the article HTML first, then mounts the registered read-only render components. It does not run the editor component in a read-only preview.
+
+`articleMarkdown(body)` calls a block's optional `toMarkdown`. Without one, it writes a fenced `rigel-extension` placeholder containing the block's name and complete JSON data. Unknown blocks also retain their data in Markdown. Published HTML throws for an unknown block rather than silently losing content. Keep the extension registered while articles still use it, or migrate those articles before removing it.
+
+## Data and trust
+
+A custom block is a root-level article node with exactly this shape:
+
+```json
+{
+  "type": "extension",
+  "version": 1,
+  "name": "cta",
+  "data": { "label": "Contact us", "href": "/contact/" }
+}
+```
+
+Custom blocks have no children. Data must be a bounded JSON object. Rigel checks that boundary and your block's `validate(data)` checks its schema and domain rules. Throw an error for invalid data. Validate URLs as URLs or restrict them to a known safe format; Svelte's attribute escaping does not make an unsafe URL safe.
+
+Extension modules and Svelte components are trusted application code. Review them like any other dependency. Article content stores data and a registered name, never executable code or import locations. Rigel does not fetch modules, evaluate code from content, or install extensions at runtime. Use normal Svelte interpolation for content values; passing untrusted data to `{@html}` bypasses its escaping.

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "@rigel-cms/rigel",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A CMS for Astro sites. You edit the text, Git keeps the history.",
+  "keywords": [
+    "astro",
+    "astro-integration",
+    "astro-component",
+    "withastro",
+    "cms",
+    "git-based-cms",
+    "svelte",
+    "typescript"
+  ],
   "author": {
     "name": "FreshJuice",
     "email": "contact@freshjuice.dev",
@@ -34,14 +44,17 @@
     ".": "./src/index.ts",
     "./content": "./src/content.ts",
     "./preview": "./src/preview.ts",
-    "./article": "./src/article-render.ts",
+    "./article": "./src/article.ts",
+    "./extensions": "./src/extensions.ts",
     "./types": "./src/env.d.ts",
     "./routes/*": "./src/routes/*"
   },
   "files": [
     "src",
     "!src/**/*.test.ts",
-    "README.md"
+    "README.md",
+    "docs/extensions.md",
+    "docs/content-locales.md"
   ],
   "peerDependencies": {
     "astro": "^7.3.0",

package/src/article-body.ts

@@ -1,6 +1,8 @@
 import type { SerializedEditorState } from "lexical";
+import { validateBlockData, validateExtensionName } from "./extensions";
 import { safePreviewUrl } from "./preview-urls";
 import { safeEmbed } from "./editor/lib/embeds";
+import { systemMessage, type Translator } from "./editor/i18n/format";
 
 export type ArticleBody = SerializedEditorState;
 export type ArticleNode = { type: string; version: number; children?: ArticleNode[]; text?: string; format?: number | string; tag?: string; listType?: string; start?: number; url?: string; src?: string; alt?: string; credit?: string; creditURL?: string; [key: string]: unknown };
@@ -12,56 +14,66 @@ export function emptyBody(): ArticleBody {
   return { root: { type: "root", version: 1, children: [paragraph], direction: null, format: "", indent: 0 } };
 }
 
-export function validateBody(value: unknown): asserts value is ArticleBody {
+export function validateBody(value: unknown, message: Translator = systemMessage): asserts value is ArticleBody {
   const types = new Set(["root", "paragraph", "heading", "quote", "list", "listitem", "code", "text", "linebreak", "link", "image", "video", "embed", "divider", "table", "tablerow", "tablecell"]);
   let count = 0;
   let textSize = 0;
   function check(raw: unknown, parent = "", depth = 0) {
-    if (++count > 10000 || depth > 32 || !raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Invalid or oversized article block tree");
+    if (++count > 10000 || depth > 32 || !raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(message("validation.body.invalidTree"));
     const node = raw as ArticleNode;
-    if (!types.has(node.type) || node.version !== 1 || (node.type === "root") !== !parent) throw new Error("Unsupported article block");
+    if (Object.hasOwn(node, "type") && node.type === "extension") {
+      const prototype = Object.getPrototypeOf(node);
+      if ((prototype !== Object.prototype && prototype !== null) || parent !== "root" || Reflect.ownKeys(node).length !== 4 || ["type", "version", "name", "data"].some(key => {
+        const descriptor = Object.getOwnPropertyDescriptor(node, key);
+        return !descriptor?.enumerable || !Object.hasOwn(descriptor, "value");
+      }) || node.version !== 1) throw new Error("rigel: invalid extension block envelope");
+      validateExtensionName(node.name);
+      validateBlockData(node.data);
+      return;
+    }
+    if (!types.has(node.type) || node.version !== 1 || (node.type === "root") !== !parent) throw new Error(message("validation.body.unsupportedBlock"));
     const inline = ["text", "linebreak", "link"];
-    if (parent === "root" && (inline.includes(node.type) || ["listitem", "tablerow", "tablecell"].includes(node.type))) throw new Error("Expected an article block");
-    if (node.type === "table" && parent !== "root") throw new Error("Nested tables are not supported");
-    if (node.type === "tablerow" && parent !== "table" || node.type === "tablecell" && parent !== "tablerow") throw new Error("Invalid table structure");
-    if (parent === "table" && node.type !== "tablerow" || parent === "tablerow" && node.type !== "tablecell" || parent === "tablecell" && node.type !== "paragraph") throw new Error("Invalid table content");
+    if (parent === "root" && (inline.includes(node.type) || ["listitem", "tablerow", "tablecell"].includes(node.type))) throw new Error(message("validation.body.expectedBlock"));
+    if (node.type === "table" && parent !== "root") throw new Error(message("validation.body.nestedTable"));
+    if (node.type === "tablerow" && parent !== "table" || node.type === "tablecell" && parent !== "tablerow") throw new Error(message("validation.body.tableStructure"));
+    if (parent === "table" && node.type !== "tablerow" || parent === "tablerow" && node.type !== "tablecell" || parent === "tablecell" && node.type !== "paragraph") throw new Error(message("validation.body.tableContent"));
     if (node.type === "tablecell") {
-      if (![0, 1, 2, 3].includes(Number(node.headerState)) || typeof node.headerState !== "number" || (node.colSpan ?? 1) !== 1 || (node.rowSpan ?? 1) !== 1) throw new Error("Invalid table cell or unsupported merged cells");
-      if (node.backgroundColor || node.verticalAlign) throw new Error("Custom table cell styles are not supported");
+      if (![0, 1, 2, 3].includes(Number(node.headerState)) || typeof node.headerState !== "number" || (node.colSpan ?? 1) !== 1 || (node.rowSpan ?? 1) !== 1) throw new Error(message("validation.body.tableCell"));
+      if (node.backgroundColor || node.verticalAlign) throw new Error(message("validation.body.tableCellStyles"));
     }
-    for (const key of ["width", "height"]) if (node[key] !== undefined && (typeof node[key] !== "number" || !Number.isFinite(node[key]) || node[key] <= 0 || node[key] > 2000)) throw new Error("Invalid table dimensions");
-    if (node.colWidths !== undefined && (!Array.isArray(node.colWidths) || node.colWidths.length > MAX_TABLE_COLUMNS || node.colWidths.some(width => typeof width !== "number" || !Number.isFinite(width) || width <= 0 || width > 2000))) throw new Error("Invalid table column widths");
-    if (parent === "list" && node.type !== "listitem") throw new Error("Lists require list items");
-    if (["paragraph", "heading", "link", "code"].includes(parent) && !inline.includes(node.type)) throw new Error("Expected inline article content");
-    if (node.type === "heading" && !["h1", "h2", "h3", "h4", "h5", "h6"].includes(node.tag ?? "")) throw new Error("Use heading levels 1–6");
-    if (node.type === "list" && !["bullet", "number"].includes(node.listType ?? "")) throw new Error("Unsupported list type");
-    if (node.start !== undefined && (!Number.isInteger(node.start) || node.start < 1 || node.start > 1000000)) throw new Error("Invalid list start");
-    if (node.type === "text" && (typeof node.text !== "string" || typeof node.format !== "number" || !Number.isInteger(node.format) || node.format < 0 || node.format > 255)) throw new Error("Invalid article text");
-    if (node.type === "text" && (textSize += node.text!.length) > 1000000) throw new Error("Article text is too large");
-    if (node.style || node.textStyle) throw new Error("Custom article styles are not supported");
-    if (node.type === "image" && (typeof node.src !== "string" || typeof node.alt !== "string")) throw new Error("Images require a URL and alt text");
-    if (node.type === "link" && typeof node.url !== "string") throw new Error("Links require a URL");
-    if (node.type === "image" && !safePreviewUrl(node.src!, true)) throw new Error("Unsafe image URL");
-    if (node.type === "image" && node.url !== undefined && (typeof node.url !== "string" || node.url && !safePreviewUrl(node.url))) throw new Error("Unsafe image link URL");
-    if (node.type === "link" && !safePreviewUrl(node.url!)) throw new Error("Unsafe link URL");
-    if (node.type === "video" && (typeof node.src !== "string" || !safePreviewUrl(node.src, true))) throw new Error("Unsafe video URL");
-    if (node.type === "video" && node.poster !== undefined && (typeof node.poster !== "string" || !safePreviewUrl(node.poster, true))) throw new Error("Unsafe video poster URL");
-    if (node.type === "video" && node.caption !== undefined && typeof node.caption !== "string") throw new Error("Invalid video caption");
-    if (node.type === "video") for (const key of ["muted", "controls"]) if (node[key] !== undefined && typeof node[key] !== "boolean") throw new Error("Invalid video playback setting");
-    if (node.type === "embed" && (!safeEmbed(node) || typeof node.privacy !== "boolean")) throw new Error("Invalid video embed");
-    if (node.type === "embed" && node.title !== undefined && typeof node.title !== "string") throw new Error("Invalid embed title");
-    for (const key of ["credit", "creditURL"]) if (node[key] !== undefined && typeof node[key] !== "string") throw new Error("Invalid image credit");
-    if (node.creditURL && !safePreviewUrl(node.creditURL)) throw new Error("Unsafe image credit URL");
+    for (const key of ["width", "height"]) if (node[key] !== undefined && (typeof node[key] !== "number" || !Number.isFinite(node[key]) || node[key] <= 0 || node[key] > 2000)) throw new Error(message("validation.body.tableDimensions"));
+    if (node.colWidths !== undefined && (!Array.isArray(node.colWidths) || node.colWidths.length > MAX_TABLE_COLUMNS || node.colWidths.some(width => typeof width !== "number" || !Number.isFinite(width) || width <= 0 || width > 2000))) throw new Error(message("validation.body.tableColumnWidths"));
+    if (parent === "list" && node.type !== "listitem") throw new Error(message("validation.body.listItems"));
+    if (["paragraph", "heading", "link", "code"].includes(parent) && !inline.includes(node.type)) throw new Error(message("validation.body.inlineContent"));
+    if (node.type === "heading" && !["h1", "h2", "h3", "h4", "h5", "h6"].includes(node.tag ?? "")) throw new Error(message("validation.body.headingLevel"));
+    if (node.type === "list" && !["bullet", "number"].includes(node.listType ?? "")) throw new Error(message("validation.body.listType"));
+    if (node.start !== undefined && (!Number.isInteger(node.start) || node.start < 1 || node.start > 1000000)) throw new Error(message("validation.body.listStart"));
+    if (node.type === "text" && (typeof node.text !== "string" || typeof node.format !== "number" || !Number.isInteger(node.format) || node.format < 0 || node.format > 255)) throw new Error(message("validation.body.invalidText"));
+    if (node.type === "text" && (textSize += node.text!.length) > 1000000) throw new Error(message("validation.body.textSize"));
+    if (node.style || node.textStyle) throw new Error(message("validation.body.customStyles"));
+    if (node.type === "image" && (typeof node.src !== "string" || typeof node.alt !== "string")) throw new Error(message("validation.body.imageRequired"));
+    if (node.type === "link" && typeof node.url !== "string") throw new Error(message("validation.body.linkRequired"));
+    if (node.type === "image" && !safePreviewUrl(node.src!, true)) throw new Error(message("validation.body.imageUrl"));
+    if (node.type === "image" && node.url !== undefined && (typeof node.url !== "string" || node.url && !safePreviewUrl(node.url))) throw new Error(message("validation.body.imageLinkUrl"));
+    if (node.type === "link" && !safePreviewUrl(node.url!)) throw new Error(message("validation.body.linkUrl"));
+    if (node.type === "video" && (typeof node.src !== "string" || !safePreviewUrl(node.src, true))) throw new Error(message("validation.body.videoUrl"));
+    if (node.type === "video" && node.poster !== undefined && (typeof node.poster !== "string" || !safePreviewUrl(node.poster, true))) throw new Error(message("validation.body.videoPosterUrl"));
+    if (node.type === "video" && node.caption !== undefined && typeof node.caption !== "string") throw new Error(message("validation.body.videoCaption"));
+    if (node.type === "video") for (const key of ["muted", "controls"]) if (node[key] !== undefined && typeof node[key] !== "boolean") throw new Error(message("validation.body.videoPlayback"));
+    if (node.type === "embed" && (!safeEmbed(node) || typeof node.privacy !== "boolean")) throw new Error(message("validation.body.videoEmbed"));
+    if (node.type === "embed" && node.title !== undefined && typeof node.title !== "string") throw new Error(message("validation.body.embedTitle"));
+    for (const key of ["credit", "creditURL"]) if (node[key] !== undefined && typeof node[key] !== "string") throw new Error(message("validation.body.imageCredit"));
+    if (node.creditURL && !safePreviewUrl(node.creditURL)) throw new Error(message("validation.body.imageCreditUrl"));
     if (!["text", "linebreak", "image", "video", "embed", "divider"].includes(node.type)) {
-      if (!Array.isArray(node.children)) throw new Error("Article block requires children");
+      if (!Array.isArray(node.children)) throw new Error(message("validation.body.childrenRequired"));
       for (const child of node.children) check(child, node.type, depth + 1);
-      if (["table", "tablerow", "tablecell"].includes(node.type) && !node.children.length) throw new Error("Table elements cannot be empty");
+      if (["table", "tablerow", "tablecell"].includes(node.type) && !node.children.length) throw new Error(message("validation.body.emptyTable"));
       if (node.type === "table") {
         const columns = node.children[0]?.children?.length ?? 0;
-        if (node.children.length > MAX_TABLE_ROWS || columns > MAX_TABLE_COLUMNS || node.children.some(row => row.children?.length !== columns)) throw new Error("Table must be rectangular and at most 50 rows by 20 columns");
+        if (node.children.length > MAX_TABLE_ROWS || columns > MAX_TABLE_COLUMNS || node.children.some(row => row.children?.length !== columns)) throw new Error(message("validation.body.tableSize"));
       }
-    } else if (node.children !== undefined) throw new Error("Unexpected article children");
+    } else if (node.children !== undefined) throw new Error(message("validation.body.unexpectedChildren"));
   }
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected a Lexical article body");
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message("validation.body.expectedBody"));
   check((value as ArticleBody).root);
 }

package/src/article-render.ts

@@ -11,13 +11,29 @@ function renderText(node: ArticleNode): string {
   return text;
 }
 
-export function renderArticle(body: ArticleBody, options: { preview?: boolean } = {}): string {
+export interface ArticleRenderOptions {
+  preview?: boolean;
+  renderExtension?: (name: string, data: import("./extensions").BlockData) => string;
+}
+
+export interface ArticleMarkdownOptions {
+  extensionMarkdown?: (name: string, data: import("./extensions").BlockData) => string | undefined;
+}
+
+export function renderArticle(body: ArticleBody, options: ArticleRenderOptions = {}): string {
   validateBody(body);
   function walk(node: ArticleNode): string {
     const content = () => (node.children ?? []).map(walk).join("");
     if (node.type === "text") return renderText(node);
     if (node.type === "linebreak") return "<br>";
     if (node.type === "root") return content();
+    if (node.type === "extension") {
+      const name = node.name as string;
+      const data = node.data as import("./extensions").BlockData;
+      if (options.preview) return `<figure data-rigel-extension="${escape(name)}" data-rigel-extension-data="${escape(JSON.stringify(data))}"></figure>`;
+      if (!options.renderExtension) throw new Error(`No renderer registered for extension block "${name}"`);
+      return options.renderExtension(name, data);
+    }
     if (node.type === "paragraph") return `<p>${content()}</p>`;
     if (node.type === "heading") return `<${node.tag}>${content()}</${node.tag}>`;
     if (node.type === "quote") return `<blockquote>${content()}</blockquote>`;
@@ -62,11 +78,18 @@ function plain(node: ArticleNode): string {
   return node.type === "text" ? node.text ?? "" : node.type === "linebreak" ? "\n" : (node.children ?? []).map(plain).join("");
 }
 
-export function articleMarkdown(body: ArticleBody): string {
+export function articleMarkdown(body: ArticleBody, options: ArticleMarkdownOptions = {}): string {
   validateBody(body);
   const escaped = (text: string) => text.replace(/[\\`*_[\]<>#~]/g, "\\$&");
   function walk(node: ArticleNode, depth = 0): string {
     const content = () => (node.children ?? []).map(child => walk(child, depth)).join("");
+    if (node.type === "extension") {
+      const markdown = options.extensionMarkdown?.(node.name as string, node.data as import("./extensions").BlockData);
+      if (markdown !== undefined) return markdown + "\n\n";
+      const serialized = JSON.stringify({ type: "extension", version: 1, name: node.name, data: node.data });
+      const fence = "`".repeat(Math.max(3, ...(serialized.match(/`+/g) ?? []).map(run => run.length + 1)));
+      return `${fence}rigel-extension\n${serialized}\n${fence}\n\n`;
+    }
     if (node.type === "text") {
       let text = escaped(node.text ?? "");
       const format = Number(node.format);

package/src/article.ts

@@ -0,0 +1,44 @@
+import { render } from "svelte/server";
+import extensions from "virtual:rigel-extensions";
+import { resolveExtensions, type BlockData } from "./extensions";
+import { renderArticle as renderBody, articleMarkdown as markdownBody, type ArticleRenderOptions, type ArticleMarkdownOptions } from "./article-render";
+import type { ArticleBody } from "./article-body";
+
+export type { ArticleRenderOptions, ArticleMarkdownOptions } from "./article-render";
+
+const registry = resolveExtensions(extensions);
+
+function blockFor(name: string, data: BlockData) {
+  const block = registry.blocks.find(block => block.name === name);
+  if (!block) throw new Error(`No renderer registered for extension block "${name}"`);
+  block.validate(data);
+  return block;
+}
+
+export function renderArticle(body: ArticleBody, options: ArticleRenderOptions & { onHead?: (head: string) => void } = {}): string {
+  const head = new Set<string>();
+  let index = 0;
+  const html = renderBody(body, {
+    ...options,
+    renderExtension: (name, data) => {
+      const block = blockFor(name, data);
+      if (options.renderExtension) return options.renderExtension(name, data);
+      const output = render(block.render, { props: { data }, idPrefix: `rigel-extension-${index++}-` });
+      if (output.head) head.add(output.head);
+      return output.body;
+    },
+  });
+  const renderedHead = [...head].join("");
+  if (options.onHead) { options.onHead(renderedHead); return html; }
+  return renderedHead + html;
+}
+
+export function articleMarkdown(body: ArticleBody, options: ArticleMarkdownOptions = {}): string {
+  return markdownBody(body, {
+    extensionMarkdown: (name, data) => {
+      const block = registry.blocks.find(block => block.name === name);
+      block?.validate(data);
+      return options.extensionMarkdown ? options.extensionMarkdown(name, data) : block?.toMarkdown?.(data);
+    },
+  });
+}

package/src/config.ts

@@ -6,6 +6,14 @@ import { withSeoFields } from "./manifest/seo";
 import { previewBaseUrl, previewRoute } from "./preview-urls";
 import type { JsonOutput } from "./json-output";
 import { DEFAULT_MAX_FILE_SIZE } from "./media-types";
+import { systemMessage } from "./editor/i18n/format";
+import { localeNames, type Locale } from "./editor/i18n/locales";
+import { validateContentLocales, validateContentLocale } from "./manifest/content-locales";
+
+export interface ContentLocalesConfig {
+  defaultLocale: string;
+  locales: { code: string; label: string }[];
+}
 
 export interface RigelConfig {
   copyDir: string;
@@ -15,6 +23,9 @@ export interface RigelConfig {
   backend: "local" | "github";
   jsonOutput?: JsonOutput;
   demo?: boolean;
+  languages?: Locale[];
+  contentLocales?: ContentLocalesConfig;
+  extensions?: string[];
   collections?: CollectionConfig[];
   menus?: { folder: string; maxDepth?: number };
   schema?: Schema;
@@ -30,6 +41,7 @@ export interface RigelConfig {
 
 export interface CollectionConfig {
   name: string;
+  locale?: string;
   label?: string;
   listTitle?: string;
   folder: string;
@@ -44,6 +56,18 @@ const DEFAULTS: Pick<RigelConfig, "copyDir" | "backend"> = {
 
 export function parseConfig(options: Partial<RigelConfig> = {}): RigelConfig {
   const cfg = { ...DEFAULTS, ...options };
+  if (cfg.contentLocales !== undefined) {
+    validateContentLocales(cfg.contentLocales);
+    cfg.contentLocales = { ...cfg.contentLocales, locales: cfg.contentLocales.locales.map(locale => ({ ...locale })) };
+  }
+  for (const type of cfg.schema?.documents ?? []) validateContentLocale(type.locale, cfg.contentLocales, type.name);
+  for (const collection of cfg.collections ?? []) validateContentLocale(collection.locale, cfg.contentLocales, collection.name);
+  if (cfg.extensions === undefined) cfg.extensions = [];
+  if (!Array.isArray(cfg.extensions) || Array.from(cfg.extensions).some(module => typeof module !== "string" || !module.startsWith("./") || !module.slice(2).split("/").every(part => /^[a-zA-Z0-9_-][a-zA-Z0-9_.-]*$/.test(part) && part !== "node_modules" && part !== "." && part !== "..")) || new Set(cfg.extensions).size !== cfg.extensions.length) throw new Error("rigel: extensions must be unique explicit ./module paths inside the site project");
+  cfg.extensions = [...cfg.extensions];
+  if (cfg.languages === undefined) cfg.languages = ["en", "fr"];
+  if (!Array.isArray(cfg.languages) || Array.from(cfg.languages).some(language => typeof language !== "string" || !Object.hasOwn(localeNames, language))) throw new Error("rigel: languages must be an array of supported locale codes");
+  cfg.languages = [...new Set<Locale>(["en", ...cfg.languages])];
   if (cfg.maxFileSize === undefined) cfg.maxFileSize = DEFAULT_MAX_FILE_SIZE;
   if (!Number.isSafeInteger(cfg.maxFileSize) || cfg.maxFileSize <= 0) throw new Error("rigel: maxFileSize must be a positive integer in bytes");
   if (cfg.jsonOutput === undefined) cfg.jsonOutput = "pretty";
@@ -92,8 +116,8 @@ export function parseConfig(options: Partial<RigelConfig> = {}): RigelConfig {
     const schema = cfg.demo ? declared : validateSchema({ ...declared, documents: declared.documents.filter(type => !type.demo) });
     cfg.schema = { ...schema, documents: schema.documents.map(type => {
       if (type.shared) return type;
-      const fields = withSeoFields(type.fields.map(field => field.key === "title" && field.label === "Title" ? { ...field, label: "Page name" } : field));
-      if (!fields.some(field => field.key === "draft")) fields.push({ key: "draft", label: "Draft", type: "boolean" });
+      const fields = withSeoFields(type.fields);
+      if (!fields.some(field => field.key === "draft")) fields.push({ key: "draft", label: systemMessage("defaults.draft"), labelKey: "defaults.draft", type: "boolean" });
       return { ...type, fields };
     }) };
   }