@rigel-cms/rigel 0.1.4-beta.1 → 0.2.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigel-cms/rigel",
-  "version": "0.1.4-beta.1",
+  "version": "0.2.0-beta.1",
   "publishConfig": {
     "access": "public",
     "tag": "beta"

package/src/content.ts

@@ -2,4 +2,6 @@ export type { MenuItem, MenuDocument } from "./manifest/menu";
 export { defineCopy } from "./manifest/types";
 export type { CopyField, CopyGroup, CopyPage, Manifest, ManifestCollection } from "./manifest/types";
 export { defineSchema, defineDocument, defineObject, defineField } from "./schema/types";
-export type { Schema, DocumentDef, ObjectDef, FieldDef, ContentDocument } from "./schema/types";
+export type { Schema, DocumentDef, ObjectDef, FieldDef, ContentDocument } from "./schema/types";
+export { effectiveSlug } from "./slugs";
+export { pageRoute } from "./schema/paths";

package/src/editor/App.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { onMount } from "svelte";
+  import { onMount, tick } from "svelte";
   import { tooltipRoot } from "./lib/tooltip";
   onMount(() => tooltipRoot(document.body).destroy);
   import type {
@@ -20,6 +20,7 @@
   import { isSeoField } from "../manifest/seo";
   import { initialCollectionValues } from "../manifest/collections";
   import { slugify } from "./lib/slugify";
+  import { effectiveSlug, normalizeUrlSlug } from "../slugs";
   import Icon from "./lib/Icon.svelte";
   import SidebarIcon from "./lib/SidebarIcon.svelte";
   import logo from "./assets/rigelcms-icon.png?url";
@@ -29,13 +30,14 @@
   import type { MenuItem } from "../manifest/menu";
   import UnsavedChanges from "./lib/UnsavedChanges.svelte";
   import ActionDialog from "./lib/ActionDialog.svelte";
+  import PublishDialog from "./lib/PublishDialog.svelte";
   import VisualEditor from "./lib/VisualEditor.svelte";
   import { newDocumentFromTemplate } from "../schema/paths";
   import { previewUrl } from "../preview";
   import type { ContentDocument, Schema } from "../schema/types";
   import { buildSidebar, navigationKey, type Selection } from "../manifest/navigation";
   import { startGitHubLogin, checkGitHubAccess, type GitHubAccess } from "./lib/github-auth";
-  import { loadManifestRemote, saveRemoteSelection, deleteRemotePost, type GitContext } from "./lib/github-backend";
+  import { loadManifestRemote, saveRemoteSelection, deleteRemotePost, reviewRemotePublish, confirmRemotePublish, type GitContext, type PublishReview } from "./lib/github-backend";
 
   type Sel = Selection;
 
@@ -61,6 +63,75 @@
   let saveState = $state<"idle" | "saving" | "saved" | "error">("idle");
   let saveTask: Promise<boolean> | null = null;
   let saveError = $state("");
+  let publishOpen = $state(false);
+  let publishLoading = $state(false);
+  let publishBusy = $state(false);
+  let publishReview = $state<PublishReview | null>(null);
+  let publishError = $state("");
+  let publishMessage = $state("");
+  let publishRevision = 0;
+
+  function closePublish() {
+    publishRevision += 1;
+    publishOpen = false;
+    publishReview = null;
+    void tick().then(() => document.querySelector<HTMLButtonElement>("#publish-button")?.focus());
+  }
+
+  function publishGuard(context: GitContext, revision: number, auth: number) {
+    if (!publishOpen || revision !== publishRevision || auth !== authRevision || gitContext !== context) throw new Error("Publish review is no longer active. Reconnect and review again.");
+    requireGitContext();
+    if (dirty || saveTask || saveState === "saving") throw new Error("Save your unsaved edits first, then review publishing. Your edits are still here.");
+  }
+
+  async function reviewPublish() {
+    if (publishBusy || publishLoading) return;
+    publishOpen = true;
+    publishReview = null;
+    publishError = "";
+    publishMessage = "";
+    publishLoading = true;
+    const revision = ++publishRevision, auth = authRevision;
+    try {
+      const context = requireGitContext();
+      const guard = () => publishGuard(context, revision, auth);
+      guard();
+      const review = await reviewRemotePublish(context, manifest, guard);
+      guard();
+      publishReview = review;
+    } catch (error) {
+      handleAuthError(error);
+      if (revision === publishRevision) publishError = error instanceof Error ? error.message : "Could not review saved changes.";
+    } finally { publishLoading = false; }
+  }
+
+  async function publish() {
+    if (publishBusy || publishLoading || !publishReview) return;
+    publishBusy = true;
+    publishError = "";
+    const review = publishReview, revision = publishRevision, auth = authRevision;
+    try {
+      const context = requireGitContext();
+      const guard = () => publishGuard(context, revision, auth);
+      guard();
+      const result = await confirmRemotePublish(context, manifest, review, guard);
+      guard();
+      publishReview = null;
+      if (result === "synced") {
+        const remote = await loadManifestRemote(context, blueprint!, false);
+        guard();
+        manifest = remote;
+        openSelection(sel);
+        publishMessage = "Drafts synced. Nothing was published. Close this dialog and review again before publishing.";
+      } else publishMessage = `Published to ${review.publishBranch}. Your configured deployment can now start; the site is not instantly live. The drafts branch is preserved.`;
+    } catch (error) {
+      handleAuthError(error);
+      if (revision === publishRevision) {
+        publishError = error instanceof Error ? error.message : "Could not verify publishing. Check GitHub before retrying.";
+        if (/changed|no longer matches/.test(publishError)) publishReview = null;
+      }
+    } finally { publishBusy = false; }
+  }
   let pendingNavigation = $state<(() => void) | null>(null);
   let actionDialog = $state<{ title: string; description: string; confirmLabel: string; fieldLabel?: string; danger?: boolean; onconfirm: (value: string) => void | Promise<void> } | null>(null);
   let newEntry = $state<{ collection: string; post: CollectionPost } | null>(null);
@@ -129,6 +200,7 @@
   }
 
   function invalidateSession() {
+    closePublish();
     authRevision += 1;
     clearSession();
     gitContext = null;
@@ -142,7 +214,8 @@
   }
 
   async function connectGitHub() {
-    if (connectionBusy || saveState === "saving" || !manifest.github) return;
+    if (connectionBusy || saveState === "saving" || publishBusy || !manifest.github) return;
+    closePublish();
     connectionBusy = true;
     connectionError = "";
     const revision = ++authRevision;
@@ -173,6 +246,8 @@
   function signOut() {
     if (saveState === "saving" || connectionBusy) return;
     userOpen = false;
+    if (publishBusy) { invalidateSession(); connected = false; return; }
+    closePublish();
     requestNavigation(() => {
       invalidateSession();
       connected = false;
@@ -202,6 +277,7 @@
   });
 
   function save(): Promise<boolean> {
+    if (publishOpen || publishBusy) return Promise.resolve(false);
     if (saveTask) return saveTask;
     saveTask = (async () => {
       if (dirty) {
@@ -215,6 +291,10 @@
         const docSel = sel?.kind === "document" ? sel : null;
         const creatingDoc = docSel !== null && newDocument?.id === docSel.id;
         try {
+          if ((selection?.kind === "post" || (docSel && !activeDocType?.shared)) && Object.hasOwn(values, "slug")) {
+            values.slug = normalizeUrlSlug(values.slug);
+            draft.slug = values.slug;
+          }
           if (githubMode) {
             if (!selection) throw new Error("Select content before saving.");
             await saveRemoteSelection(requireGitContext(), manifest, selection, values, body, !!creating || creatingDoc);
@@ -234,7 +314,7 @@
             newDocument = null;
             docBase = JSON.parse(JSON.stringify(values));
           } else if (m) { m.title = values.title; m.items = values.items; }
-          else if (po) { po.frontmatter = { slug: po.slug, ...values }; po.body = body; bodyBase = body; }
+          else if (po) { po.frontmatter = values; po.body = body; bodyBase = body; }
           else if (p) p.values = values;
           if (creating && po && c) c.posts.push(po);
           newEntry = null;
@@ -411,8 +491,8 @@
     return map;
   });
   function documentPreview(mode: "draft" | "website") {
-    if (sel?.kind !== "document" || newDocument?.id === sel.id) return null;
-    return previewUrl(manifest.preview ?? {}, { kind: "document", type: sel.type, slug: sel.id.slice(sel.type.length + 1) }, mode);
+    if (sel?.kind !== "document" || (mode === "draft" && newDocument?.id === sel.id)) return null;
+    return previewUrl(manifest.preview ?? {}, { kind: "document", type: sel.type, slug: sel.id.slice(sel.type.length + 1), urlSlug: Object.hasOwn(draft, "slug") ? String(draft.slug) : undefined }, mode);
   }
   const standaloneDocument = $derived(sel?.kind === "document" && activeDocType?.shared === true);
   const visualSelection = $derived(sel?.kind === "post" || (sel?.kind === "document" && !standaloneDocument));
@@ -422,13 +502,13 @@
       ...manifest.pages.filter((p) => !p.shared && (pageCategory === undefined || p.category === pageCategory))
         .map((p) => ({ slug: p.slug, title: p.label, category: p.category, draft: false, target: { kind: "page", slug: p.slug } as Sel })),
       ...(pageCategory === undefined ? pageDocuments
-        .map((doc) => ({ slug: doc.slug, title: String(doc.data.title ?? doc.slug), category: undefined, draft: doc.data.draft === true, target: { kind: "document", type: doc.type, id: doc.id } as Sel })) : []),
+        .map((doc) => ({ slug: effectiveSlug(doc.data, doc.slug), title: String(doc.data.title ?? doc.slug), category: undefined, draft: doc.data.draft === true, target: { kind: "document", type: doc.type, id: doc.id } as Sel })) : []),
     ];
     const key = sortBy === "slug" || sortBy === "category" ? sortBy : "title";
     return rows.sort((a, b) => String(a[key] ?? "").localeCompare(String(b[key] ?? "")) * sortDir);
   });
   function documentCell(doc: ContentDocument, key: string): string {
-    return String(key === "title" ? doc.data.title ?? doc.data.name ?? doc.slug : key === "slug" ? doc.slug : doc.data[key] ?? "");
+    return String(key === "title" ? doc.data.title ?? doc.data.name ?? doc.slug : key === "slug" ? activeDocType?.shared ? doc.slug : effectiveSlug(doc.data, doc.slug) : doc.data[key] ?? "");
   }
   const typeDocuments = $derived((manifest.documents ?? []).filter((doc) => doc.type === docTypeName(sel)).sort((a, b) => documentCell(a, sortBy).localeCompare(documentCell(b, sortBy)) * sortDir));
 
@@ -507,6 +587,7 @@
   }
 
   function requestNavigation(action: () => void) {
+    if (publishOpen || publishBusy) return;
     if (dirty || saveState === "saving") pendingNavigation = action;
     else action();
   }
@@ -564,7 +645,6 @@
       const po = post;
       if (!po) return;
       const fm: Record<string, unknown> = { ...po.frontmatter };
-      delete fm.slug;
       draft = JSON.parse(JSON.stringify(fm));
       bodyDraft = po.body;
       bodyBase = po.body;
@@ -590,9 +670,7 @@
     }
     const ref =
       sel?.kind === "menu" && menu ? { title: menu.title, items: menu.items } : sel?.kind === "post" && post
-        ? Object.fromEntries(
-            Object.entries(post.frontmatter).filter(([k]) => k !== "slug"),
-          )
+        ? post.frontmatter
         : page?.values;
     dirty =
       newEntry !== null ||
@@ -602,7 +680,7 @@
   }
 
   function cellValue(p: { slug: string; frontmatter: Record<string, unknown> }, key: string): string {
-    const v = key === "slug" ? p.slug : p.frontmatter[key];
+    const v = key === "slug" ? effectiveSlug(p.frontmatter, p.slug) : p.frontmatter[key];
     const field = coll?.fields.find(field => field.key === key);
     if (field?.type === "reference") return referenceLabel(v, referenceOptions(field, manifest.documents)) || "—";
     if (v === true) return "✓";
@@ -618,7 +696,7 @@
       onconfirm: (title) => {
         const slug = slugify(title);
         if (!slug) throw new Error("Enter a title containing letters or numbers.");
-        const taken = [...(manifest.documents ?? []).filter(doc => !type.shared || doc.type === type.name).map((doc) => doc.slug), ...(!type.shared ? manifest.pages.map((page) => page.slug) : [])];
+        const taken = [...(manifest.documents ?? []).filter(doc => !type.shared || doc.type === type.name).flatMap((doc) => [doc.slug, ...(type.shared || docTypes.find(type => type.name === doc.type)?.shared ? [] : [effectiveSlug(doc.data, doc.slug)])]), ...(!type.shared ? manifest.pages.map((page) => page.slug) : [])];
         if (taken.includes(slug)) throw new Error(`The slug "${slug}" is already used by another document or page.`);
         const id = `${type.name}:${slug}`;
         const data = newDocumentFromTemplate(schema, type.name, title, slug);
@@ -634,15 +712,16 @@
     actionDialog = {
       title: `Add to ${c.label}`, description: "Enter a title to start a draft. Nothing is written until you press Save.", fieldLabel: "Title", confirmLabel: "Create draft",
       onconfirm: (title) => {
-        const slug = slugify(title, c.posts.map((post) => post.slug));
+        const slug = slugify(title, c.posts.flatMap((post) => [post.slug, effectiveSlug(post.frontmatter, post.slug)]));
         if (!slug) throw new Error("Enter a title containing letters or numbers.");
-        newEntry = { collection: c.name, post: { slug, frontmatter: initialCollectionValues(c.fields, title), body: emptyBody() } };
+        newEntry = { collection: c.name, post: { slug, frontmatter: { ...initialCollectionValues(c.fields, title), slug }, body: emptyBody() } };
         openSelection({ kind: "post", collection: c.name, slug });
       },
     };
   }
 
   function deletePost() {
+    if (publishOpen || publishBusy) return;
     const current = post, collection = coll, unsaved = newEntry !== null;
     if (!current || !collection) return;
     actionDialog = {
@@ -689,7 +768,7 @@
   onresize={endPreviewResize}
   onblur={endPreviewResize}
   oncontextmenu={(event) => { if (!settings.devMode) event.preventDefault(); }}
-  onbeforeunload={(event) => { if (dirty || saveState === "saving") { event.preventDefault(); event.returnValue = ""; } }}
+  onbeforeunload={(event) => { if (dirty || saveState === "saving" || publishBusy) { event.preventDefault(); event.returnValue = ""; } }}
   onclick={(e) => {
     if (!(e.target instanceof Element) || !e.target.closest('.user-menu-wrap')) userOpen = false;
   }}
@@ -771,6 +850,11 @@
       {/each}
     </nav>
 
+    {#if githubMode && manifest.github?.publishBranch}
+      <button id="publish-button" class="sidebar-publish" aria-label="Publish" data-tooltip={dirty ? "Save your edits before publishing" : "Publish saved branch changes"} disabled={publishBusy || publishLoading || saveState === "saving" || connectionBusy || tokenExpired || githubAccess?.status !== "ready"} onclick={reviewPublish}>
+        <Icon name="external" size={18} /><span class="sidebar-label">Publish</span>
+      </button>
+    {/if}
     <button class="sidebar-toggle" aria-expanded={!settings.userPref.sidebarCollapsed} aria-controls="rigel-sidebar-navigation" aria-label={settings.userPref.sidebarCollapsed ? "Expand sidebar" : "Collapse sidebar"} data-tooltip={settings.userPref.sidebarCollapsed ? "Expand sidebar" : "Collapse sidebar"} onclick={() => { settings.userPref.sidebarCollapsed = !settings.userPref.sidebarCollapsed; }}>
       <SidebarIcon name="sidebar-simple" /><span class="sidebar-label">Collapse sidebar</span>
     </button>
@@ -951,6 +1035,9 @@
         <MenuEditor items={draft.items as MenuItem[]} maxDepth={manifest.menus.maxDepth} oninput={(items) => { draft.items = items; touch(); }} />
 
       {:else if sel?.kind === "page" && page}
+        {#if !page.shared}
+          <section><label><span>Website route</span><input type="text" value={manifest.preview?.pages?.[page.slug] ?? "Not configured"} readonly /></label><p class="hint">This copy page uses a fixed Astro route. Its URL can only be changed in the website code; slug metadata cannot move it.</p></section>
+        {/if}
         {#each page.groups as group (group.id)}
           <section>
             <h3>{group.label}</h3>
@@ -979,13 +1066,13 @@
             bodyInline={settings.userPref.editorExperience === "inline"}
             onbody={(value) => { bodyDraft = value; touch(); }}
             previewPath={manifest.preview ? previewUrl(manifest.preview, sel, "draft", !!newEntry) : null}
-            websitePath={manifest.preview ? previewUrl(manifest.preview, sel, "website") : null}
+            websitePath={manifest.preview ? previewUrl(manifest.preview, { ...sel, urlSlug: Object.hasOwn(draft, "slug") ? String(draft.slug) : undefined }, "website") : null}
             creating={!!newEntry}
             devMode={settings.devMode}
             onchange={(next) => { draft = next; touch(); }}
           >
             {#snippet properties(selected, focusToken, bodyInline, oneditbody)}
-              <CollectionPanel fields={coll.fields} values={draft} documents={manifest.documents ?? []} body={bodyDraft as ArticleBody} {bodyInline} {oneditbody} {selected} {focusToken} devMode={settings.devMode} onchange={(key, value) => { draft[key] = value; touch(); }} onbody={(value) => { bodyDraft = value; touch(); }} />
+              <CollectionPanel fields={coll.fields} values={draft} storageSlug={post.slug} documents={manifest.documents ?? []} body={bodyDraft as ArticleBody} {bodyInline} {oneditbody} {selected} {focusToken} devMode={settings.devMode} onchange={(key, value) => { draft[key] = value; touch(); }} onbody={(value) => { bodyDraft = value; touch(); }} />
             {/snippet}
           </VisualEditor>
         {/key}
@@ -1025,3 +1112,6 @@
 {#if actionDialog}
   <ActionDialog {...actionDialog} onclose={() => { actionDialog = null; }} />
 {/if}
+{#if publishOpen}
+  <PublishDialog review={publishReview} loading={publishLoading} busy={publishBusy} error={publishError} message={publishMessage} onrefresh={reviewPublish} onconfirm={publish} onclose={closePublish} />
+{/if}

package/src/editor/lib/CollectionPanel.svelte

@@ -13,10 +13,12 @@
   import { referenceOptions } from "../../manifest/references";
   import { isSeoField } from "../../manifest/seo";
   import type { ContentDocument } from "../../schema/types";
+  import { slugify } from "../../slugs";
 
-  let { fields, values, body, selected, focusToken, devMode, documents = [], bodyInline = false, oneditbody = () => {}, onchange, onbody }: {
+  let { fields, values, storageSlug, body, selected, focusToken, devMode, documents = [], bodyInline = false, oneditbody = () => {}, onchange, onbody }: {
     fields: CollectionField[];
     values: Record<string, unknown>;
+    storageSlug: string;
     body: ArticleBody;
     bodyInline?: boolean;
     oneditbody?: () => void;
@@ -49,7 +51,9 @@
   <div id="properties-content" role="tabpanel" aria-labelledby="properties-tab-content" hidden={tab !== "content"}>
   <section>
     <h3>Article details</h3>
-    {#each fields.filter(field => !isSeoField(field.key)) as field (field.key)}
+    <label><span>URL slug</span><input type="text" value={String(values.slug ?? storageSlug)} oninput={(event) => onchange("slug", event.currentTarget.value)} onblur={() => { if (Object.hasOwn(values, "slug")) onchange("slug", slugify(String(values.slug))); }} /></label>
+    <p class="hint">Changes the URL, not the content filename. The website route must use the slug metadata.</p>
+    {#each fields.filter(field => field.key !== "slug" && !isSeoField(field.key)) as field (field.key)}
       <div data-collection-field={field.key}>
         {#if field.type === "reference"}
           <ReferenceSelect label={field.label} value={values[field.key]} options={referenceOptions(field, documents)} multiple={field.multiple} onchange={(value) => onchange(field.key, value)} />

package/src/editor/lib/PreviewFrame.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { untrack } from "svelte";
+  import { tick, untrack } from "svelte";
   import { fetchPreview } from "./preview-frame";
 
   let { url, title, frame = $bindable(), reloadToken = 0, onload, onloading, onerror }: {
@@ -11,35 +11,77 @@
     onloading: () => void;
     onerror: (message: string) => void;
   } = $props();
-  let source = $state<{ src?: string; srcdoc?: string } | null>(null);
+  let source = $state<{ src?: string; srcdoc?: string; ready: (event: Event) => void; fail: () => void } | null>(null);
+  let loading = $state(true);
+  let revealed = $state(false);
 
   $effect(() => {
     const target = new URL(url, location.href);
     void reloadToken;
+    const started = performance.now();
+    const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)").matches;
+    const controller = new AbortController();
+    const { signal } = controller;
     source = null;
+    loading = true;
+    revealed = false;
     untrack(onloading);
-    const controller = new AbortController();
-    if (target.origin === location.origin) source = { src: target.href };
-    else fetchPreview(target, controller.signal).then(srcdoc => {
-      if (!controller.signal.aborted) source = { srcdoc };
+    function fail(message = "The prepared page could not be loaded. Check its URL and framing headers.") {
+      if (signal.aborted) return;
+      controller.abort();
+      clearTimeout(timeout);
+      loading = false;
+      onerror(message);
+    }
+    const timeout = setTimeout(() => fail("The preview took too long to load. Check its URL and try again."), 20000);
+    function wait(ms: number) {
+      return new Promise<void>(resolve => {
+        const finish = () => { clearTimeout(timer); signal.removeEventListener("abort", finish); resolve(); };
+        const timer = setTimeout(finish, ms);
+        signal.addEventListener("abort", finish, { once: true });
+      });
+    }
+    async function ready(event: Event) {
+      const iframe = event.currentTarget as HTMLIFrameElement;
+      const doc = iframe.contentDocument;
+      if (signal.aborted) return;
+      if (!doc || (target.origin === location.origin && new URL(doc.URL).pathname.replace(/\/$/, "") !== target.pathname.replace(/\/$/, ""))) {
+        fail();
+        return;
+      }
+      try {
+        if (doc.fonts) await Promise.race([doc.fonts.ready.catch(() => {}), wait(200)]);
+        if (signal.aborted) return;
+        if (!reducedMotion) await wait(Math.max(0, 500 - (performance.now() - started)));
+        if (signal.aborted || iframe !== frame) return;
+        onload();
+        await tick();
+        if (signal.aborted || iframe !== frame) return;
+        clearTimeout(timeout);
+        loading = false;
+        revealed = true;
+      } catch (cause) {
+        fail(cause instanceof Error ? cause.message : "Preview unavailable");
+      }
+    }
+    const handlers = { ready, fail: () => fail() };
+    if (target.origin === location.origin) source = { src: target.href, ...handlers };
+    else fetchPreview(target, signal).then(srcdoc => {
+      if (!signal.aborted) source = { srcdoc, ...handlers };
     }).catch(cause => {
-      if (!controller.signal.aborted) onerror(cause instanceof Error ? cause.message : "Preview unavailable");
+      fail(cause instanceof Error ? cause.message : "Preview unavailable");
     });
-    return () => controller.abort();
+    return () => { controller.abort(); clearTimeout(timeout); };
   });
-
-  function ready() {
-    const doc = frame?.contentDocument;
-    if (!doc || (source?.src && new URL(doc.URL).pathname.replace(/\/$/, "") !== new URL(source.src).pathname.replace(/\/$/, ""))) {
-      onerror("The prepared page could not be loaded. Check its URL and framing headers.");
-      return;
-    }
-    onload();
-  }
 </script>
 
-{#if source}
-  {#key source}
-  <iframe bind:this={frame} {title} sandbox="allow-same-origin" referrerpolicy="no-referrer" src={source.src} srcdoc={source.srcdoc} onload={ready}></iframe>
-  {/key}
-{/if}
+<div class="preview-frame" aria-busy={loading}>
+  {#if source}
+    {#key source}
+      <iframe bind:this={frame} {title} sandbox="allow-same-origin" referrerpolicy="no-referrer" src={source.src} srcdoc={source.srcdoc} onload={source.ready} onerror={source.fail} class:revealed inert={!revealed} aria-hidden={!revealed}></iframe>
+    {/key}
+  {/if}
+  {#if loading}
+    <div class="preview-loading" role="status"><span class="preview-spinner" aria-hidden="true"></span>Loading preview…</div>
+  {/if}
+</div>

package/src/editor/lib/PublishDialog.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+  import Icon from "./Icon.svelte";
+  import type { PublishReview } from "./github-backend";
+  let { review, loading, busy, error, message, onrefresh, onconfirm, onclose }: {
+    review: PublishReview | null; loading: boolean; busy: boolean; error: string; message: string;
+    onrefresh: () => void; onconfirm: () => void; onclose: () => void;
+  } = $props();
+  let dialog: HTMLDialogElement;
+  let cancel: HTMLButtonElement;
+  $effect(() => {
+    dialog.showModal();
+    cancel.focus();
+    return () => dialog.close();
+  });
+</script>
+
+<dialog bind:this={dialog} class="rigel rigel-modal-backdrop publish-dialog" aria-labelledby="publish-title" aria-describedby="publish-description" oncancel={(event) => { event.preventDefault(); if (!busy) onclose(); }}>
+  <form class="rigel-modal" onsubmit={(event) => { event.preventDefault(); onconfirm(); }} aria-busy={loading || busy}>
+    <div class="publish-head"><h2 id="publish-title">Publish saved changes</h2><button type="button" class="icon-btn" aria-label="Close publish review" disabled={busy} onclick={onclose}><Icon name="x" size={16} /></button></div>
+    <p id="publish-description">Publish includes <strong>all saved changes on the drafts branch</strong>, including files outside CMS content folders. Unsaved edits are never included or saved automatically.</p>
+    {#if loading}<p role="status">Loading the complete file review…</p>{/if}
+    {#if review}
+      <p><strong>{review.repo}</strong><br /><span class="publish-branch">{review.branch}</span> to <span class="publish-branch">{review.publishBranch}</span>, as one squash commit.</p>
+      {#if review.needsSync}
+        <p>The publishing branch has changes not in drafts, including earlier squash publishes. First, explicitly sync it into drafts using GitHub’s normal merge. This does not publish. Conflicts stop the sync. Then review the updated files again before publishing.</p>
+        <p>These are the current tree differences, not the final publish list:</p>
+      {/if}
+      <p id="publish-file-count"><strong>{review.files.length} {review.files.length === 1 ? "file" : "files"}</strong></p>
+      {#if review.files.length}
+        <ul class="publish-files" tabindex="0" aria-label="All changed files" aria-describedby="publish-file-count">
+          {#each review.files as file (file.filename)}
+            <li><span class="publish-file-status">{file.status}</span><span>{file.filename}{#if file.previous_filename}<small>Previously: {file.previous_filename}</small>{/if}</span></li>
+          {/each}
+        </ul>
+      {:else}<p>No saved changes to publish. The branch trees are identical.</p>{/if}
+      <p class="hint">Both branch revisions are checked again before publishing. GitHub pins the draft revision, but cannot atomically lock the target revision; a target update in the final instant can still race. Required checks, reviews and branch protections apply.</p>
+    {/if}
+    {#if error}<p class="error" role="alert">{error}</p>{/if}
+    {#if message}<p role="status">{message}</p>{/if}
+    <div class="publish-actions">
+      <button type="button" bind:this={cancel} class="outlined" disabled={busy} onclick={onclose}>{message ? "Close" : "Cancel"}</button>
+      {#if !message}<button type="button" class="outlined" disabled={loading || busy} onclick={onrefresh}>Review again</button>{/if}
+      {#if review && !message}<button id="confirm-publish" type="submit" class="primary" disabled={loading || busy || !review.files.length}>{busy ? "Working…" : review.needsSync ? "Sync drafts first" : "Confirm publish"}</button>{/if}
+    </div>
+  </form>
+</dialog>
+
+<style>
+  .publish-dialog { box-sizing: border-box; width: 100%; height: 100%; max-width: none; max-height: none; margin: 0; padding: 1rem; border: none; color: var(--text); }
+  .publish-dialog:not([open]) { display: none; }
+  .publish-dialog::backdrop { background: transparent; }
+  .publish-dialog .rigel-modal { box-sizing: border-box; width: min(42rem, 100%); max-height: calc(100dvh - 2rem); overflow-y: auto; overflow-wrap: anywhere; }
+  .publish-head, .publish-actions { display: flex; align-items: center; gap: 0.75rem; }
+  .publish-head { justify-content: space-between; }
+  .publish-actions { justify-content: flex-end; flex-wrap: wrap; margin-top: 1.5rem; }
+  .publish-dialog button { min-height: 44px; }
+  .publish-head .icon-btn { min-width: 44px; }
+  .publish-branch { font-weight: 600; }
+  .publish-files { list-style: none; margin: 0; padding: 0; max-height: min(35dvh, 20rem); overflow-y: auto; border: 1px solid var(--border); }
+  .publish-files li { display: grid; grid-template-columns: 5rem minmax(0, 1fr); gap: 0.75rem; padding: 0.625rem; border-bottom: 1px solid var(--border); font-size: 0.8125rem; }
+  .publish-files li:last-child { border-bottom: none; }
+  .publish-files small { display: block; margin-top: 0.25rem; }
+  .publish-file-status { text-transform: capitalize; }
+  button:disabled { opacity: 0.5; cursor: not-allowed; }
+</style>

package/src/editor/lib/SchemaPanel.svelte

@@ -19,6 +19,7 @@
   import { resolvePath } from "../../schema/paths";
   import { isSeoField } from "../../manifest/seo";
   import type { ContentDocument, DocumentDef, Schema } from "../../schema/types";
+  import { slugify } from "../../slugs";
 
   let {
     schema, docType, values, docId, selected, creating, pending, documents, focusToken, devMode, onchange, onselect, oneditdocument,
@@ -46,7 +47,7 @@
   const selectedField = $derived(selected?.docId === docId ? fieldForPath(schema, docType, values, selected.path) : null);
   const selectedSection = $derived(selected?.sectionKey ? sectionTypeDef(schema, sections.find((section) => section._key === selected?.sectionKey)?._type) : undefined);
   const selectedValue = $derived(selected && selectedField ? resolvePath(values, selected.path).value : undefined);
-  const docFields = $derived(docType.fields.filter((field) => field.key !== "sections"));
+  const docFields = $derived(docType.fields.filter((field) => field.key !== "sections" && (docType.shared || field.key !== "slug")));
   const seoFields = $derived(docType.shared ? [] : docFields.filter(field => isSeoField(field.key)));
 
   $effect(() => {
@@ -97,6 +98,10 @@
   {#if seoFields.length}<PropertiesTabs bind:tab />{/if}
   <section class="document-properties" hidden={tab !== "content"}>
     <h3>{docType.shared ? "Content" : "Page properties"}</h3>
+    {#if !docType.shared}
+      <label><span>URL slug</span><input type="text" value={String(values.slug ?? docId.slice(docType.name.length + 1))} oninput={(event) => onchange({ ...values, slug: event.currentTarget.value })} onblur={() => { if (Object.hasOwn(values, "slug")) onchange({ ...values, slug: slugify(String(values.slug)) }); }} /></label>
+      <p class="hint">Changes the URL, not the document identifier or filename. The website route must use the slug metadata.</p>
+    {/if}
     {#each docFields.filter(field => docType.shared || !isSeoField(field.key)) as field (field.key)}
       <div data-schema-path={field.key}>
         <SchemaField {schema} {documents} {devMode} {field} base={field.key} value={values[field.key]} onvalue={(next) => onchange(replaceAt(values, field.key, next))} />

package/src/editor/lib/github-backend.ts

@@ -5,12 +5,13 @@ import { validateMenu } from "../../manifest/menu";
 import { validateCollectionValues } from "../../manifest/collections";
 import { documentIndex, isPlainObject, validateDocument, validateDocumentId, validateSchema } from "../../schema/validate";
 import { applyValues, readValues } from "../../routes/serialize";
+import { assertUniqueUrlSlugs, normalizeUrlSlug, validateDocumentSlugs } from "../../slugs";
 
 export interface GitContext { token: string; repo: string; branch: string }
 
-type FileSnapshot = { sha: string; text: string };
-type PendingWrite = { sha: string; text: string | null; creating: boolean };
-type Snapshot = { target: string; files: Map<string, FileSnapshot>; paths: Set<string>; pending: Map<string, PendingWrite> };
+type FileSnapshot = { sha: string; text: string; mode: string };
+type PendingWrite = { sha: string; text: string | null; creating: boolean; head: string; mode: string };
+type Snapshot = { target: string; head: string; writes: Promise<void>; files: Map<string, FileSnapshot>; paths: Set<string>; pending: Map<string, PendingWrite> };
 const REMOTE_SNAPSHOT = Symbol("rigel-remote-snapshot");
 const SHA = /^[a-f0-9]{40}$/;
 const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -71,11 +72,11 @@ function sha(value: unknown): string {
   return value;
 }
 
-async function draftHead(ctx: GitContext, manifest: Manifest): Promise<string> {
+async function draftHead(ctx: GitContext, manifest: Manifest, create = true): Promise<string> {
   const cfg = config(ctx, manifest);
   const ref = `/git/ref/heads/${encodeURIComponent(ctx.branch)}`;
   try { return sha((await gh(ctx, ref))?.object?.sha); }
-  catch (error) { if (!(error instanceof GitError) || error.status !== 404) throw error; }
+  catch (error) { if (!create || !(error instanceof GitError) || error.status !== 404) throw error; }
   const base = sha((await gh(ctx, `/git/ref/heads/${encodeURIComponent(cfg.publishBranch)}`))?.object?.sha);
   try { await gh(ctx, "/git/refs", {method:"POST", body:JSON.stringify({ref:`refs/heads/${ctx.branch}`,sha:base})}); }
   catch (error) { if (!(error instanceof GitError) || ![409,422].includes(error.status)) throw error; }
@@ -105,13 +106,13 @@ function parseJson(text: string): unknown {
   try { return JSON.parse(text); } catch { throw new Error("Invalid remote content JSON"); }
 }
 
-export async function loadManifestRemote(ctx: GitContext, blueprint: Manifest): Promise<Manifest> {
+export async function loadManifestRemote(ctx: GitContext, blueprint: Manifest, createDraft = true): Promise<Manifest> {
   const cfg = config(ctx, blueprint);
-  const head = await draftHead(ctx, blueprint);
+  const head = await draftHead(ctx, blueprint, createDraft);
   const tree = await gh(ctx, `/git/trees/${head}?recursive=1`);
   if (!tree || tree.truncated !== false || !Array.isArray(tree.tree)) throw new Error("Incomplete GitHub tree; content cannot be loaded safely");
   const manifest = structuredClone(blueprint);
-  const snapshot: Snapshot = {target:target(ctx,manifest),files:new Map(),paths:new Set(),pending:new Map()};
+  const snapshot: Snapshot = {target:target(ctx,manifest),head,writes:Promise.resolve(),files:new Map(),paths:new Set(),pending:new Map()};
   const entries = new Map<string, any>();
   for (const entry of tree.tree) {
     if (!entry || typeof entry.path !== "string" || entry.path.split("/").some((part: string) => !part || part === "." || part === "..") || /[\\\u0000-\u001f]/.test(entry.path) || !["blob","tree","commit"].includes(entry.type) || !SHA.test(entry.sha) || !["100644","100755","120000","040000","160000"].includes(entry.mode)) throw new Error("Malformed GitHub tree entry");
@@ -132,7 +133,7 @@ export async function loadManifestRemote(ctx: GitContext, blueprint: Manifest):
     const expected = sha(entry.sha);
     const blob = await gh(ctx, `/git/blobs/${expected}`);
     if (sha(blob?.sha) !== expected) throw new Error("GitHub blob SHA mismatch");
-    const text = decode(blob); snapshot.files.set(path,{sha:expected,text}); return text;
+    const text = decode(blob); snapshot.files.set(path,{sha:expected,text,mode:entry.mode}); return text;
   };
   const list = (folder: string, pattern = SLUG) => {
     const prefix = [cfg.repoRoot,folder].filter(Boolean).join("/") + "/";
@@ -156,6 +157,7 @@ export async function loadManifestRemote(ctx: GitContext, blueprint: Manifest):
   }
   documentIndex(manifest.documents);
   for (const doc of manifest.documents) validateDocument(manifest.schema!,doc.type,doc.slug,doc.data,manifest.documents);
+  if (manifest.schema) validateDocumentSlugs(manifest.schema, manifest.documents, manifest.preview);
   for (const collection of manifest.collections ?? []) {
     const folder = cfg.collections.find(c => c.name === collection.name)?.folder;
     if (!folder) throw new Error("Missing configured GitHub collection");
@@ -166,6 +168,7 @@ export async function loadManifestRemote(ctx: GitContext, blueprint: Manifest):
       validateBody(post.body); validateCollectionValues(collection.fields,post.frontmatter,manifest.documents);
       collection.posts.push({slug:file.slug,frontmatter:post.frontmatter,body:post.body});
     }
+    assertUniqueUrlSlugs(collection.posts.map(post => ({ slug: post.slug, values: post.frontmatter })));
   }
   if (cfg.menus) {
     manifest.menus = {maxDepth:cfg.menus.maxDepth,entries:[]};
@@ -188,8 +191,17 @@ function loaded(ctx: GitContext, manifest: Manifest): Snapshot {
 
 async function mutate(ctx: GitContext, manifest: Manifest, path: string, text: string | null, creating: boolean) {
   const snapshot = loaded(ctx,manifest);
+  const head = sha((await gh(ctx, `/git/ref/heads/${encodeURIComponent(ctx.branch)}`))?.object?.sha);
+  const uncertain = snapshot.pending.get(path);
+  if (head !== snapshot.head && head !== uncertain?.head) throw new Error("GitHub draft branch conflict; reload before saving. Your unsaved edits are still here.");
   const endpoint = `/contents/${path.split("/").map(encodeURIComponent).join("/")}`;
   const verify = async (pending: PendingWrite) => {
+    const current = sha((await gh(ctx, `/git/ref/heads/${encodeURIComponent(ctx.branch)}`))?.object?.sha);
+    if (current !== pending.head) {
+      if (current !== snapshot.head) throw new Error("GitHub draft branch conflict; reload before saving.");
+      const result = await gh(ctx, `/git/refs/heads/${encodeURIComponent(ctx.branch)}`, { method: "PATCH", body: JSON.stringify({ sha: pending.head, force: false }) });
+      if (sha(result?.object?.sha) !== pending.head) throw new Error("GitHub branch update could not be verified; retry or reload.");
+    }
     let verified;
     try { verified = await gh(ctx,`${endpoint}?ref=${encodeURIComponent(ctx.branch)}`); }
     catch (error) {
@@ -200,11 +212,11 @@ async function mutate(ctx: GitContext, manifest: Manifest, path: string, text: s
       snapshot.files.delete(path); snapshot.paths.delete(path);
     } else {
       if (verified?.type !== "file" || sha(verified.sha) !== pending.sha || decode(verified) !== pending.text) throw new Error("GitHub save changed before verification; reload");
-      snapshot.files.set(path,{sha:pending.sha,text:pending.text}); snapshot.paths.add(path);
+      snapshot.files.set(path,{sha:pending.sha,text:pending.text,mode:pending.mode}); snapshot.paths.add(path);
     }
+    snapshot.head = pending.head;
     snapshot.pending.delete(path);
   };
-  const uncertain = snapshot.pending.get(path);
   if (uncertain) {
     await verify(uncertain);
     if (uncertain.text === text && (!creating || uncertain.creating)) return;
@@ -212,14 +224,27 @@ async function mutate(ctx: GitContext, manifest: Manifest, path: string, text: s
   }
   const previous = snapshot.files.get(path);
   if (creating ? snapshot.paths.has(path) : !previous) throw new Error(creating ? "Content already exists; choose another slug" : "Reload this content before changing it");
-  const payload = {message:`rigel: ${text === null ? "delete" : "save"} ${path}`,branch:ctx.branch,...(!creating ? {sha:previous!.sha} : {}),...(text === null ? {} : {content:encode(text)})};
-  const result = await gh(ctx,endpoint,{method:text === null ? "DELETE" : "PUT",body:JSON.stringify(payload)});
-  const pending = {sha:text === null ? previous!.sha : sha(result?.content?.sha),text,creating};
+  const blob = text === null ? null : sha((await gh(ctx, "/git/blobs", { method: "POST", body: JSON.stringify({ content: encode(text), encoding: "base64" }) }))?.sha);
+  const mode = previous?.mode ?? "100644";
+  const base = sha((await gh(ctx, `/git/commits/${snapshot.head}`))?.tree?.sha);
+  const tree = sha((await gh(ctx, "/git/trees", { method: "POST", body: JSON.stringify({ base_tree: base, tree: [{ path, mode, type: "blob", sha: blob }] }) }))?.sha);
+  const commit = sha((await gh(ctx, "/git/commits", { method: "POST", body: JSON.stringify({ message: `rigel: ${text === null ? "delete" : "save"} ${path}`, tree, parents: [snapshot.head] }) }))?.sha);
+  const pending = {sha:blob ?? previous!.sha,text,creating,head:commit,mode};
   snapshot.pending.set(path,pending);
   await verify(pending);
 }
 
-export async function saveRemoteSelection(ctx: GitContext, manifest: Manifest, selection: Selection, values: Record<string, unknown>, body: ArticleBody | "", creating: boolean): Promise<void> {
+export async function saveRemoteSelection(...args: Parameters<typeof saveSelection>): Promise<void> {
+  const key = writeKey(args[0]);
+  if (publishing.has(key)) throw new Error("Wait for publishing to finish before saving.");
+  const snapshot = loaded(args[0], args[1]);
+  saving.set(key, (saving.get(key) ?? 0) + 1);
+  const result = snapshot.writes.then(() => saveSelection(...args));
+  snapshot.writes = result.catch(() => {});
+  try { await result; } finally { saving.set(key, (saving.get(key) ?? 1) - 1); }
+}
+
+async function saveSelection(ctx: GitContext, manifest: Manifest, selection: Selection, values: Record<string, unknown>, body: ArticleBody | "", creating: boolean): Promise<void> {
   const cfg = config(ctx,manifest);
   const snapshot = loaded(ctx,manifest);
   if (!isPlainObject(values)) throw new Error("Content values must be an object");
@@ -238,15 +263,27 @@ export async function saveRemoteSelection(ctx: GitContext, manifest: Manifest, s
     if (!folder || !collection) throw new Error("Unknown collection");
     validateBody(body); validateCollectionValues(collection.fields,values,manifest.documents ?? []);
     path = filePath(ctx,manifest,folder,selection.slug,"json",POST_SLUG);
-    data = {frontmatter:{...values,slug:selection.slug},body};
+    const frontmatter = { ...values };
+    if (Object.hasOwn(frontmatter, "slug")) frontmatter.slug = normalizeUrlSlug(frontmatter.slug);
+    const prefix = filePath(ctx,manifest,folder,"placeholder","json",POST_SLUG).replace(/placeholder\.json$/, "");
+    const others = [...snapshot.files].filter(([file]) => file.startsWith(prefix) && file !== path && file.endsWith(".json")).map(([file, value]) => ({ slug: file.slice(prefix.length, -5), values: (parseJson(value.text) as { frontmatter: Record<string, unknown> }).frontmatter }));
+    assertUniqueUrlSlugs([...others, { slug: selection.slug, values: frontmatter }]);
+    data = {frontmatter,body};
   } else if (selection.kind === "document") {
     if (!manifest.schema) throw new Error("No document schema configured");
     const document = validateDocumentId(manifest.schema,selection.id);
     if (!document || document.type.name !== selection.type) throw new Error("Unknown document type or slug");
     if (creating && (document.type.creatable === false || document.type.singleton)) throw new Error("Creating entries is disabled for this document type");
-    data = {...values,_id:selection.id,_type:selection.type,slug:document.slug};
+    const next = {...values,_id:selection.id,_type:selection.type} as Record<string, unknown>;
+    if (!document.type.shared && Object.hasOwn(next, "slug")) next.slug = normalizeUrlSlug(next.slug);
+    data = next;
     validateDocument(manifest.schema,selection.type,document.slug,data as Record<string,unknown>,manifest.documents ?? []);
     path = filePath(ctx,manifest,document.type.folder,document.slug);
+    const documents = manifest.schema.documents.flatMap(type => {
+      const prefix = filePath(ctx,manifest,type.folder,"placeholder").replace(/placeholder\.json$/, "");
+      return [...snapshot.files].filter(([file]) => file.startsWith(prefix) && file !== path && file.endsWith(".json")).map(([file, value]) => ({ id: `${type.name}:${file.slice(prefix.length,-5)}`, type: type.name, slug: file.slice(prefix.length,-5), data: parseJson(value.text) as Record<string, unknown> }));
+    });
+    validateDocumentSlugs(manifest.schema, [...documents, { id: selection.id, type: selection.type, slug: document.slug, data: next }], manifest.preview);
   } else if (selection.kind === "menu") {
     if (!cfg.menus || creating) throw new Error("Menus must be configured by the site developer");
     data = validateMenu({...values,slug:selection.slug},cfg.menus.maxDepth);
@@ -255,9 +292,171 @@ export async function saveRemoteSelection(ctx: GitContext, manifest: Manifest, s
   await mutate(ctx,manifest,path,JSON.stringify(data,null,2) + "\n",creating);
 }
 
+export interface PublishFile { filename: string; status: "added" | "modified" | "removed" | "renamed"; previous_filename?: string }
+export interface PublishReview {
+  repo: string; branch: string; publishBranch: string; head: string; base: string;
+  files: PublishFile[]; needsSync: boolean; prNumber?: number; creationUncertain?: boolean;
+}
+
+async function publishHeads(ctx: GitContext, publishBranch: string, request: typeof gh) {
+  const head = sha((await request(ctx, `/git/ref/heads/${encodeURIComponent(ctx.branch)}`))?.object?.sha);
+  const base = sha((await request(ctx, `/git/ref/heads/${encodeURIComponent(publishBranch)}`))?.object?.sha);
+  return { head, base };
+}
+
+async function publishTree(ctx: GitContext, head: string, request: typeof gh) {
+  const data = await request(ctx, `/git/trees/${head}?recursive=1`);
+  if (data?.truncated !== false || !Array.isArray(data.tree)) throw new Error("Incomplete GitHub tree. Publishing is unavailable; review this change on GitHub.");
+  const files = new Map<string, string>();
+  const paths = new Set<string>();
+  for (const entry of data.tree) {
+    if (!entry || typeof entry.path !== "string" || !entry.path || /[\u0000-\u001f\u007f\\\\]/.test(entry.path) || entry.path.split("/").some((p: string) => !p || p === "." || p === "..") || paths.has(entry.path) || !["blob", "tree", "commit"].includes(entry.type) || !["100644", "100755", "120000", "040000", "160000"].includes(entry.mode)) throw new Error("Malformed GitHub publish tree");
+    if (!({ blob: ["100644", "100755", "120000"], tree: ["040000"], commit: ["160000"] } as Record<string, string[]>)[entry.type]?.includes(entry.mode)) throw new Error("Malformed GitHub publish tree mode");
+    paths.add(entry.path);
+    const id = sha(entry.sha);
+    if (entry.type !== "tree") files.set(entry.path, `${entry.mode}:${entry.type}:${id}`);
+  }
+  return files;
+}
+
+export async function reviewRemotePublish(ctx: GitContext, manifest: Manifest, assertActive: () => void = () => {}): Promise<PublishReview> {
+  const cfg = config(ctx, manifest);
+  const request: typeof gh = (context, path, init) => { assertActive(); return gh(context, path, init); };
+  const repository = await request(ctx, "");
+  if (repository?.permissions?.push !== true) throw new Error("Publishing requires repository write access.");
+  if (repository.allow_squash_merge !== true) throw new Error("Squash merging is disabled. Ask the repository owner to enable it before publishing.");
+  if (repository.delete_branch_on_merge !== false) throw new Error("Ask the repository owner to disable automatic head-branch deletion before publishing, so the drafts branch is preserved.");
+  const { head, base } = await publishHeads(ctx, cfg.publishBranch, request);
+  const [source, destination] = await Promise.all([publishTree(ctx, head, request), publishTree(ctx, base, request)]);
+  const changed = new Set([...source.keys(), ...destination.keys()].filter(path => source.get(path) !== destination.get(path)));
+  const review: PublishReview = { repo: ctx.repo, branch: ctx.branch, publishBranch: cfg.publishBranch, head, base, files: [], needsSync: false };
+  if (changed.size) {
+    const comparison = await request(ctx, `/compare/${base}...${head}?per_page=1&page=1`);
+    if (sha(comparison?.base_commit?.sha) !== base) throw new Error("GitHub comparison does not match the reviewed target.");
+    review.needsSync = sha(comparison?.merge_base_commit?.sha) !== base;
+    if (review.needsSync) {
+      review.files = [...changed].sort().map(filename => ({ filename, status: !source.has(filename) ? "removed" : !destination.has(filename) ? "added" : "modified" }));
+    } else {
+      if (!Array.isArray(comparison.files) || comparison.files.length >= 300) throw new Error("GitHub comparisons of 300 or more files are not supported. Publish this change on GitHub; no partial list is shown.");
+      const covered = new Set<string>();
+      for (const file of comparison.files) {
+        if (!file || typeof file.filename !== "string" || covered.has(file.filename) || !changed.has(file.filename) || !["added", "removed", "modified", "renamed"].includes(file.status)) throw new Error("Incomplete or unsupported GitHub file comparison. Publish this change on GitHub.");
+        covered.add(file.filename);
+        if (file.status === "renamed") {
+          if (typeof file.previous_filename !== "string" || !changed.has(file.previous_filename) || covered.has(file.previous_filename)) throw new Error("Incomplete GitHub rename comparison");
+          covered.add(file.previous_filename);
+        }
+        review.files.push({ filename: file.filename, status: file.status, ...(file.status === "renamed" ? { previous_filename: file.previous_filename } : {}) });
+      }
+      if (covered.size !== changed.size) throw new Error("Incomplete GitHub file comparison. Publishing is unavailable; no partial list is shown.");
+    }
+    if (review.files.length >= 300) throw new Error("Publishing 300 or more files is not supported. Review and publish this change on GitHub.");
+  }
+  const current = await publishHeads(ctx, cfg.publishBranch, request);
+  if (current.head !== head || current.base !== base) throw new Error("Branches changed during review. Review changes again before publishing.");
+  assertActive();
+  return review;
+}
+
+const publishing = new Set<string>();
+const saving = new Map<string, number>();
+const writeKey = (ctx: GitContext) => `${ctx.repo}:${ctx.branch}`;
+
+export async function confirmRemotePublish(ctx: GitContext, manifest: Manifest, review: PublishReview, assertActive: () => void = () => {}): Promise<"published" | "synced"> {
+  const cfg = config(ctx, manifest), key = writeKey(ctx);
+  if (publishing.has(key) || saving.get(key)) throw new Error("Wait for the current save or publish to finish.");
+  if (review.repo !== ctx.repo || review.branch !== ctx.branch || review.publishBranch !== cfg.publishBranch || !review.files.length) throw new Error("Review saved changes before publishing.");
+  sha(review.head); sha(review.base);
+  publishing.add(key);
+  const request: typeof gh = (context, path, init) => { assertActive(); return gh(context, path, init); };
+  const unchanged = async () => {
+    const current = await publishHeads(ctx, cfg.publishBranch, request);
+    if (current.head !== review.head || current.base !== review.base) throw new Error("Branches changed. Review changes again before publishing.");
+  };
+  const matches = (pr: any) => pr?.head?.repo?.full_name?.toLowerCase() === ctx.repo.toLowerCase() && pr?.base?.repo?.full_name?.toLowerCase() === ctx.repo.toLowerCase() && pr.head.ref === ctx.branch && pr.base.ref === cfg.publishBranch;
+  const validate = (pr: any) => {
+    if (!matches(pr) || !Number.isSafeInteger(pr.number) || pr.number <= 0 || pr.head.sha !== review.head) throw new Error("Pull request no longer matches this review. Review changes again.");
+    return pr;
+  };
+  const merged = (pr: any) => {
+    validate(pr);
+    if (pr.merged === true && pr.state === "closed") { sha(pr.merge_commit_sha); return true; }
+    return false;
+  };
+  const find = async () => {
+    const found: any[] = [];
+    for (let page = 1; page <= 100; page++) {
+      const query = new URLSearchParams({ state: "open", head: `${ctx.repo.split("/")[0]}:${ctx.branch}`, base: cfg.publishBranch, per_page: "100", page: String(page) });
+      const list = await request(ctx, `/pulls?${query}`);
+      if (!Array.isArray(list)) throw new Error("Incomplete GitHub pull request listing");
+      found.push(...list.filter(matches));
+      if (found.length > 1) throw new Error("Multiple matching pull requests. Resolve them on GitHub before publishing.");
+      if (list.length < 100) return found[0];
+    }
+    throw new Error("Incomplete GitHub pull request listing; publishing stopped.");
+  };
+  try {
+    if (review.prNumber) {
+      const previous = await request(ctx, `/pulls/${review.prNumber}`);
+      if (merged(previous)) return "published";
+    }
+    await unchanged();
+    const repository = await request(ctx, "");
+    if (repository?.permissions?.push !== true || repository.allow_squash_merge !== true || repository.delete_branch_on_merge !== false) throw new Error("Publishing settings or access changed. Enable squash merges, disable automatic branch deletion and verify write access, then review again.");
+    let pr = review.prNumber ? await request(ctx, `/pulls/${review.prNumber}`) : await find();
+    if (!pr) {
+      if (review.creationUncertain) throw new Error("The previous pull request creation is unconfirmed. Check GitHub before retrying; no duplicate was created.");
+      await unchanged();
+      review.creationUncertain = true;
+      try {
+        pr = await request(ctx, "/pulls", { method: "POST", body: JSON.stringify({ title: `Publish ${ctx.branch} to ${cfg.publishBranch}`, head: ctx.branch, base: cfg.publishBranch, draft: false, maintainer_can_modify: false }) });
+      } catch (error) {
+        pr = await find();
+        if (!pr) throw error;
+      }
+    }
+    validate(pr);
+    review.prNumber = pr.number;
+    pr = validate(await request(ctx, `/pulls/${pr.number}`));
+    if (merged(pr)) return "published";
+    if (pr.state !== "open" || pr.draft || pr.base.sha !== review.base) throw new Error("Pull request or target changed. Review changes again before publishing.");
+    if (review.needsSync) {
+      await unchanged();
+      await request(ctx, `/pulls/${pr.number}/update-branch`, { method: "PUT", body: JSON.stringify({ expected_head_sha: review.head }) });
+      const updated = await request(ctx, `/pulls/${pr.number}`);
+      if (!matches(updated) || updated.state !== "open" || sha(updated.head.sha) === review.head) throw new Error("GitHub is still syncing drafts, or the sync could not be verified. Wait, reload draft content and review again. Nothing was published.");
+      return "synced";
+    }
+    if (pr.mergeable !== true || pr.mergeable_state !== "clean") throw new Error("GitHub has not allowed this merge. Resolve conflicts, required checks, reviews or branch protections on GitHub, then retry. No protection is bypassed.");
+    await unchanged();
+    let failure: unknown;
+    try {
+      const result = await request(ctx, `/pulls/${pr.number}/merge`, { method: "PUT", body: JSON.stringify({ merge_method: "squash", sha: review.head }) });
+      if (result?.merged !== true) failure = new Error("GitHub did not merge the pull request. Check required checks, reviews and branch protections, then retry.");
+    } catch (error) { failure = error; }
+    let verified;
+    try { verified = await request(ctx, `/pulls/${pr.number}`); }
+    catch (error) {
+      if (error instanceof GitError && error.status === 401) throw error;
+      throw new Error(`Publish outcome is unconfirmed. Check pull request #${pr.number} on GitHub, or retry to verify it before starting another publish.`);
+    }
+    if (merged(verified)) return "published";
+    if (failure) throw failure;
+    throw new Error("The publish result could not be verified. Check this pull request on GitHub before retrying.");
+  } catch (error) {
+    if (error instanceof GitError && [403, 404].includes(error.status)) throw new GitError("Publishing requires GitHub App Contents and Pull requests read/write permissions, installation-owner approval and repository write access. Reconnect after approval. Branch protections still apply.", error.status);
+    if (error instanceof GitError && [405, 409, 422].includes(error.status)) throw new GitError("GitHub rejected publishing. Check conflicts, required checks/reviews, branch protections and squash settings. Review changes again if either branch moved.", error.status);
+    throw error;
+  } finally { publishing.delete(key); }
+}
+
 export async function deleteRemotePost(ctx: GitContext, manifest: Manifest, collection: string, slug: string): Promise<void> {
+  const key = writeKey(ctx);
+  if (publishing.has(key)) throw new Error("Wait for publishing to finish before deleting.");
   const cfg = config(ctx,manifest);
   const folder = cfg.collections.find(c => c.name === collection)?.folder;
   if (!folder || !manifest.collections?.some(c => c.name === collection)) throw new Error("Unknown collection");
-  await mutate(ctx,manifest,filePath(ctx,manifest,folder,slug,"json",POST_SLUG),null,false);
-}
+  saving.set(key, (saving.get(key) ?? 0) + 1);
+  try { await mutate(ctx,manifest,filePath(ctx,manifest,folder,slug,"json",POST_SLUG),null,false); }
+  finally { saving.set(key, (saving.get(key) ?? 1) - 1); }
+}

package/src/editor/lib/slugify.ts

@@ -1,15 +1 @@
-export function slugify(input: string, existingSlugs: Iterable<string> = []): string {
-  const base = input
-    .normalize("NFKD")
-    .replace(/[̀-ͯ]/g, "") // combining marks → strip (é→e)
-    .toLowerCase()
-    .trim()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .replace(/-{2,}/g, "-");
-  if (!base) return "";
-  const existing = new Set(existingSlugs);
-  let slug = base;
-  for (let suffix = 2; existing.has(slug); suffix++) slug = `${base}-${suffix}`;
-  return slug;
-}
+export { slugify } from "../../slugs";

package/src/editor/styles.css

@@ -175,6 +175,8 @@
 .rigel .rail-scroll > button:hover { background: var(--surface-raised); color: var(--text); }
 .rigel .sidebar-asset-icon { display: inline-block; width: 18px; height: 18px; flex-shrink: 0; background-color: currentColor; mask-image: var(--sidebar-icon); mask-position: center; mask-size: contain; mask-repeat: no-repeat; }
 .rigel .rail-scroll > button { gap: 0.625rem; }
+.rigel aside > button.sidebar-publish { gap: 0.625rem; width: calc(100% - 1.5rem); min-height: 44px; margin: 0 0.75rem 0.5rem; padding: 0.625rem; border: 1px solid var(--border-control); color: var(--text); }
+.rigel aside > button.sidebar-publish:disabled { opacity: 0.5; cursor: not-allowed; }
 .rigel aside > button.sidebar-toggle { gap: 0.625rem; width: calc(100% - 1.5rem); margin: 0 0.75rem 0.5rem; padding: 0.625rem; font-size: 0.75rem; }
 @media (min-width: 768px) {
   .rigel.sidebar-collapsed { --sidebar-w: 64px; }
@@ -186,6 +188,7 @@
   .rigel.sidebar-collapsed .user-btn > .user-menu-icon { display: none; }
   .rigel.sidebar-collapsed .rail-scroll > button,
   .rigel.sidebar-collapsed .search-trigger,
+  .rigel.sidebar-collapsed .sidebar-publish,
   .rigel.sidebar-collapsed .sidebar-toggle { justify-content: center; }
   .rigel.sidebar-collapsed .sidebar-heading { height: 1px; font-size: 0; padding: 0; margin: 0.75rem 0.625rem; border-top: 1px solid var(--border-subtle); }
   .rigel.sidebar-collapsed .aside-foot { padding: 0.75rem 0.5rem; }
@@ -365,7 +368,18 @@
 .rigel .preview-heading span, .rigel .site-preview small { color: var(--text-muted); font-size: 0.75rem; }
 .rigel .site-preview p { overflow-wrap: anywhere; font-size: 0.8125rem; }
 .rigel .site-preview .preview-error { color: var(--danger); }
-.rigel .site-preview iframe { flex: 1; width: 100%; min-height: 300px; border: 1px solid var(--border); background: white; }
+.rigel .preview-frame { position: relative; display: flex; flex-direction: column; flex: 1; min-height: 0; min-width: 0; background: var(--panel); }
+.rigel .preview-frame iframe { opacity: 0; visibility: hidden; transition: none; }
+.rigel .preview-frame iframe.revealed { opacity: 1; visibility: visible; transition: opacity 200ms ease-out; }
+.rigel .preview-loading { position: absolute; inset: 0; display: flex; align-items: center; justify-content: center; gap: 0.625rem; color: var(--text); background: var(--panel); font-size: 0.8125rem; }
+.rigel .preview-spinner { width: 1rem; height: 1rem; border: 2px solid var(--border); border-top-color: currentColor; border-radius: 50%; animation: preview-spin 800ms linear infinite; }
+@keyframes preview-spin { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) {
+  .rigel .preview-spinner { animation: none; }
+  .rigel .preview-frame iframe.revealed { transition: none; }
+}
+.rigel .site-preview .preview-frame { min-height: 300px; border: 1px solid var(--border); }
+.rigel .site-preview iframe { flex: 1; width: 100%; min-height: 0; border: 0; background: white; }
 .rigel .site-preview small { padding-top: 0.75rem; }
 .rigel .preview-retry { align-self: start; }
 @media (max-width: 1050px) {

package/src/env.d.ts

@@ -17,6 +17,6 @@ declare module "virtual:rigel-content" {
 
 declare module "virtual:rigel-config" {
   import type { RigelConfig } from "@rigel-cms/rigel";
-  const config: Pick<RigelConfig, "copyDir" | "backend" | "demo" | "collections" | "menus" | "mediaDir" | "schema"> & { publicDir?: string; root?: string };
+  const config: Pick<RigelConfig, "copyDir" | "backend" | "demo" | "collections" | "menus" | "mediaDir" | "schema" | "preview"> & { publicDir?: string; root?: string };
   export default config;
 }

package/src/preview.ts

@@ -1,6 +1,7 @@
 import MarkdownIt from "markdown-it";
 import DOMPurify from "dompurify";
 import { pageRoute } from "./schema/paths";
+import { slugify } from "./slugs";
 import { renderArticle } from "./article-render";
 import { safePreviewUrl, previewBaseUrl } from "./preview-urls";
 export { safePreviewUrl } from "./preview-urls";
@@ -20,6 +21,7 @@ export interface PreviewConfig {
 export interface PreviewTarget {
   kind: "page" | "post" | "menu" | "document";
   slug: string;
+  urlSlug?: string;
   collection?: string;
   type?: string;
 }
@@ -31,6 +33,11 @@ export function previewPath(config: PreviewConfig, target: PreviewTarget, isNew
 }
 
 export function previewUrl(config: PreviewConfig, target: PreviewTarget, mode: "live" | "draft" | "website" = "draft", isNew = false): string | null {
+  if (mode !== "draft" && target.kind !== "page" && target.urlSlug !== undefined) {
+    const slug = slugify(target.urlSlug);
+    if (!slug) return null;
+    target = { ...target, slug };
+  }
   const path = previewPath(config, target, mode === "draft" && (target.kind === "post" || isNew));
   const base = mode === "live" ? config.liveUrl : config.draftUrl;
   if (!path || base === undefined) return path;

package/src/routes/local-documents.ts

@@ -46,7 +46,7 @@ export const GET: APIRoute = async ({ params }) => {
   const target = validateDocumentId(guarded.schema, id);
   if (!target) return new Response("Unknown document", { status: 404 });
   try {
-    const documents = await readDocuments(guarded.schema, guarded.root);
+    const documents = await readDocuments(guarded.schema, guarded.root, config.preview);
     const document = documents.find((entry) => entry.id === id);
     if (!document) return new Response("Unknown document", { status: 404 });
     return Response.json(document);
@@ -66,10 +66,10 @@ const handle: APIRoute = async ({ request, params }) => {
   if (!target) return new Response("Unknown document type or slug", { status: 400 });
   try {
     const data = await readBody(request);
-    const documents = await readDocuments(guarded.schema, guarded.root);
-    const next = { ...data, _id: id, _type: target.type.name, slug: target.slug };
+    const documents = await readDocuments(guarded.schema, guarded.root, config.preview);
+    const next = { ...data, _id: id, _type: target.type.name };
     validateDocument(guarded.schema, target.type.name, target.slug, next, documents);
-    await writeDocument(guarded.schema, guarded.root, target.type.name, target.slug, next, request.method === "POST" ? "create" : "update");
+    await writeDocument(guarded.schema, guarded.root, target.type.name, target.slug, next, request.method === "POST" ? "create" : "update", config.preview);
     return new Response(null, { status: 204 });
   } catch (error) {
     if (error instanceof DocumentStoreError) return new Response(error.message, { status: error.status });

package/src/routes/local-post.ts

@@ -1,5 +1,6 @@
 import type { APIRoute } from "astro";
-import { writeFile, mkdir, rm, readFile, rename, link } from "node:fs/promises";
+import { writeFile, mkdir, rm, readFile, readdir, rename, link } from "node:fs/promises";
+import { assertUniqueUrlSlugs, normalizeUrlSlug } from "../slugs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 
@@ -23,7 +24,14 @@ function safeSlug(slug: string): string | null {
   return /^[a-z0-9][a-z0-9_-]*$/.test(slug) ? slug : null;
 }
 
-export const POST: APIRoute = async ({ request, params }) => {
+let writes: Promise<unknown> = Promise.resolve();
+export const POST: APIRoute = (context) => {
+  const result = writes.then(() => savePost(context));
+  writes = result.catch(() => {});
+  return result;
+};
+
+const savePost: APIRoute = async ({ request, params }) => {
   if (import.meta.env.PROD) {
     return new Response("Local backend is dev-only", { status: 404 });
   }
@@ -45,13 +53,17 @@ export const POST: APIRoute = async ({ request, params }) => {
   try {
     validateBody(body.body);
     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)) : [];
+    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 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 }]);
   } catch (error) {
     return new Response(error instanceof Error ? error.message : "Invalid article", { status: 400 });
   }
   await mkdir(path.dirname(file), { recursive: true });
-  const fm = { ...body.frontmatter, slug };
+  const fm = { ...body.frontmatter };
   const temporary = `${file}.${randomUUID()}.tmp`;
   try {
     await writeFile(temporary, JSON.stringify({ frontmatter: fm, body: body.body }, null, 2) + "\n", { flag: "wx" });

package/src/schema/paths.ts

@@ -1,4 +1,5 @@
 import { documentDef, isPlainObject, objectDef } from "./validate";
+import { effectiveSlug } from "../slugs";
 import {
   SLUG_PATTERN,
   type ContentDocument,
@@ -128,8 +129,9 @@ export function assertUniqueSlug(documents: ContentDocument[], typeName: string,
   if (legacySlugs.includes(slug)) throw new Error(`The slug "${slug}" is already used by a copy page.`);
 }
 
-export function pageRoute(slug: string, mapping: { url: string; index?: string } | undefined): string | null {
+export function pageRoute(target: string | Pick<ContentDocument, "slug" | "data">, mapping: { url: string; index?: string } | undefined): string | null {
   if (!mapping) return null;
+  const slug = typeof target === "string" ? target : effectiveSlug(target.data, target.slug);
   if (slug === "home" && mapping.index) return mapping.index;
   const path = mapping.url.replaceAll("{slug}", slug);
   return /^\/(?!\/)/.test(path) && !/[\\\s?#]/.test(path) && !path.split("/").includes("..") && !/^\/rigel(?:\/|$)/.test(path) ? path : null;

package/src/schema/store.ts

@@ -4,6 +4,8 @@ import path from "node:path";
 import { constants } from "node:fs";
 import { isPlainObject } from "./validate";
 import { SLUG_PATTERN, type ContentDocument, type Schema } from "./types";
+import { normalizeUrlSlug, validateDocumentSlugs } from "../slugs";
+import type { PreviewConfig } from "../preview";
 
 const MAX_BYTES = 1024 * 1024;
 const FOLDER_PART = /^[a-zA-Z0-9_-][a-zA-Z0-9_. -]*$/;
@@ -68,7 +70,7 @@ async function ensureFolder(root: string, folder: string): Promise<string> {
   return directory;
 }
 
-export async function readDocuments(schema: Schema, root: string): Promise<ContentDocument[]> {
+export async function readDocuments(schema: Schema, root: string, preview?: PreviewConfig): Promise<ContentDocument[]> {
   const documents: ContentDocument[] = [];
   for (const type of schema.documents) {
     let directory: string;
@@ -88,6 +90,8 @@ export async function readDocuments(schema: Schema, root: string): Promise<Conte
       documents.push({ id: `${type.name}:${slug}`, type: type.name, slug, data: data as Record<string, unknown> });
     }
   }
+  try { validateDocumentSlugs(schema, documents, preview); }
+  catch (error) { throw new DocumentStoreError((error as Error).message); }
   return documents;
 }
 
@@ -96,13 +100,21 @@ export async function readDocument(schema: Schema, root: string, typeName: strin
   return documents.find((doc) => doc.type === typeName && doc.slug === slug) ?? null;
 }
 
-export async function writeDocument(
+let writes: Promise<void> = Promise.resolve();
+export function writeDocument(...args: Parameters<typeof writeDocumentFile>): Promise<void> {
+  const result = writes.then(() => writeDocumentFile(...args));
+  writes = result.catch(() => {});
+  return result;
+}
+
+async function writeDocumentFile(
   schema: Schema,
   root: string,
   typeName: string,
   slug: string,
   data: Record<string, unknown>,
   mode: "create" | "update",
+  preview?: PreviewConfig,
 ): Promise<void> {
   const type = schema.documents.find((entry) => entry.name === typeName);
   if (!type) throw new DocumentStoreError(`Unknown document type ${typeName}`, 404);
@@ -118,6 +130,13 @@ export async function writeDocument(
   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);
+  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);
+  } catch (error) { throw new DocumentStoreError((error as Error).message); }
   const serialized = JSON.stringify(data, null, 2) + "\n";
   if (Buffer.byteLength(serialized) > MAX_BYTES) throw new DocumentStoreError("Document exceeds the 1 MiB limit", 413);
   const temporary = path.join(directory, `.${slug}-${randomUUID()}.tmp`);

package/src/slugs.ts

@@ -0,0 +1,46 @@
+import type { ContentDocument, Schema } from "./schema/types";
+import type { PreviewConfig } from "./preview";
+
+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, "-");
+  if (!base) return "";
+  const existing = new Set(existingSlugs);
+  let slug = base;
+  for (let suffix = 2; existing.has(slug); suffix++) slug = `${base}-${suffix}`;
+  return slug;
+}
+
+export function normalizeUrlSlug(value: unknown): string {
+  if (typeof value !== "string" || !slugify(value)) throw new Error("URL slug must contain letters or numbers.");
+  return slugify(value);
+}
+
+export function effectiveSlug(values: Record<string, unknown>, storageSlug: string): 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.");
+  return values.slug;
+}
+
+export function assertUniqueUrlSlugs(entries: { slug: string; values: Record<string, unknown> }[]): 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.`);
+    seen.add(slug);
+  }
+}
+
+export function validateDocumentSlugs(schema: Schema, documents: ContentDocument[], preview?: PreviewConfig): 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);
+  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 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.`);
+    seen.add(route);
+  }
+}

package/src/vite/manifest-plugin.ts

@@ -22,7 +22,8 @@ export function rigelManifestPlugin(cfg: RigelConfig, publicDir?: URL, root?: UR
     ...(cfg.menus ? { menus: { folder: cfg.menus.folder, maxDepth: cfg.menus.maxDepth! } } : {}),
   } : undefined;
 
-  const documentsSrc = documentTypes.length
+  const slugHelpers = `import { assertUniqueUrlSlugs as __rigelAssertUniqueUrlSlugs, validateDocumentSlugs as __rigelValidateDocumentSlugs } from ${JSON.stringify(fileURLToPath(new URL("../slugs.ts", import.meta.url)))};`;
+  const documentsSrc = slugHelpers + (documentTypes.length
     ? `
 ${documentTypes.map((type, index) => `const __rigelDoc${index} = import.meta.glob(${JSON.stringify(`/${type.folder}/*.json`)}, { eager: true, import: "default" });`).join("\n")}
 export const documentTypes = ${JSON.stringify(documentTypes.map((type) => ({ name: type.name, shared: Boolean(type.shared) })))};
@@ -33,9 +34,10 @@ export const documents = Object.entries(__rigelRawDocuments)
     return { id: type + ":" + slug, type, slug, data: { ...data, _id: type + ":" + slug, _type: type } };
   }))
   .sort((a, b) => a.id.localeCompare(b.id));
+__rigelValidateDocumentSlugs(${JSON.stringify(cfg.schema)}, documents, ${JSON.stringify(cfg.preview)});
 const __rigelReservedSlugs = new Set(documents.filter((doc) => !documentTypes.find((type) => type.name === doc.type).shared).map((doc) => doc.slug));
 `
-    : `export const documentTypes = [];\nexport const documents = [];\nconst __rigelReservedSlugs = new Set();\n`;
+    : `export const documentTypes = [];\nexport const documents = [];\nconst __rigelReservedSlugs = new Set();\n`);
 
   const collectionCode = collections
     .map(
@@ -137,6 +139,7 @@ export const menus = {
           menus: cfg.menus,
           collections: cfg.collections ?? [],
           schema: cfg.schema,
+          preview: cfg.preview,
         })};`;
       }
       if (id === "\0" + CONTENT_ID) {
@@ -174,6 +177,7 @@ export const pages = loaded.filter((page) => !__rigelReservedSlugs.has(page.slug
 export const collections = [
 ${collectionCode}
 ];
+for (const collection of collections) __rigelAssertUniqueUrlSlugs(collection.posts.map(post => ({ slug: post.slug, values: post.frontmatter })));
 ${menuCode}
 export default { pages, collections, documents${github ? ', backend: "github", github: ' + JSON.stringify(github) : ""}${cfg.menus ? ", menus" : ""}${cfg.schema ? ", schema: " + JSON.stringify(cfg.schema) : ""}${cfg.preview ? ", preview: " + JSON.stringify(cfg.preview) : ""}${cfg.sidebar ? ", sidebar: " + JSON.stringify(cfg.sidebar) : ""} };
 `;