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

package/src/editor/lib/VisualEditor.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
   import { mount, unmount, onDestroy, tick, type Snippet } from "svelte";
   import BlockEditor from "./BlockEditor.svelte";
+  import { tooltipRoot } from "./tooltip";
   import editorStyles from "../styles.css?inline";
   import type { ArticleBody } from "../../article-body";
   import { patchPreview } from "../../preview";
@@ -13,7 +14,7 @@
   import type { ContentDocument, DocumentDef, Schema } from "../../schema/types";
 
   let {
-    docId, schema, docType, values, previewValues, documents = {}, previewPath, livePath = previewPath, body = "", bodyInline = false, onbody = () => {}, properties, creating, devMode, reloadToken = 0, onchange, oneditdocument = () => {},
+    docId, schema, docType, values, previewValues, documents = {}, previewPath, websitePath, body = "", bodyInline = false, onbody = () => {}, properties, creating, devMode, reloadToken = 0, onchange, oneditdocument = () => {},
   }: {
     docId: string;
     schema?: Schema;
@@ -22,7 +23,7 @@
     previewValues?: Record<string, unknown>;
     documents?: Record<string, Record<string, unknown>>;
     previewPath: string | null;
-    livePath?: string | null;
+    websitePath?: string | null;
     body?: "" | import("../../article-body").ArticleBody;
     properties?: Snippet<[SelectedField | null, number, boolean, () => void]>;
     bodyInline?: boolean;
@@ -45,6 +46,7 @@
   let bodyContents: ChildNode[] = [];
   let bodyAttributes: [string, string | null][] = [];
   let bodyScope: HTMLElement | null = null;
+  let removeTooltips: (() => void) | undefined;
   let error = $state("");
   let mode = $state<"browse" | "edit">("edit");
   let panelOpen = $state(true);
@@ -186,6 +188,7 @@
 
   function stopBodyEdit() {
     if (!bodyEditor) return;
+    removeTooltips?.(); removeTooltips = undefined;
     void unmount(bodyEditor); bodyEditor = undefined;
     bodyThemeObserver?.disconnect(); bodyThemeObserver = undefined;
     editingBody?.replaceChildren(...bodyContents);
@@ -222,6 +225,7 @@
     syncTheme();
     const host = doc.createElement("div"); host.className = "rigel rigel-inline";
     scope.append(host); doc.body.append(scope); bodyScope = scope;
+    removeTooltips = tooltipRoot(host).destroy;
     bodyEditor = mount(BlockEditor, { target: host, props: { editableRoot: element, get value() { return body as ArticleBody; }, oninput: (next: ArticleBody) => onbody(next) } });
     bodyThemeObserver = new MutationObserver(syncTheme);
     bodyThemeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ["data-theme", "data-contrast"] });
@@ -435,8 +439,8 @@
       </div>
       <span class="visual-hint">{mode === "edit" ? "Click a region to edit it. Scripts, forms and links stay disabled." : "Scripts, forms and links are disabled in this preview."}</span>
       <div class="visual-actions">
-        {#if livePath}<a class="icon-btn visual-live" href={livePath} target="_blank" rel="noopener noreferrer" aria-label="View live page" title="View live page"><Icon name="external" size={18} /></a>{/if}
-        <button type="button" class="icon-btn" aria-pressed={panelOpen} aria-label="Toggle properties panel" title="Toggle properties panel" onclick={() => (panelOpen = !panelOpen)}>
+        {#if websitePath}<a class="icon-btn visual-live" href={websitePath} target="_blank" rel="noopener noreferrer" aria-label="Preview on website" data-tooltip="Preview on website"><Icon name="external" size={18} /></a>{/if}
+        <button type="button" class="icon-btn" aria-pressed={panelOpen} aria-label="Toggle properties panel" data-tooltip="Toggle properties panel" onclick={() => (panelOpen = !panelOpen)}>
           <SidebarIcon name="square-half" />
         </button>
       </div>

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

@@ -1,5 +1,5 @@
 export interface GitHubAccess {
-  user: { login: string; avatar_url: string; html_url: string };
+  user: { login: string; name?: string; avatar_url: string; html_url: string };
   status: "ready" | "installation-required" | "read-only";
   installUrl: string;
   installation: { id: number; account: string; html_url: string } | null;
@@ -63,7 +63,7 @@ export async function checkGitHubAccess(token: string, repo: string, appSlug: st
       });
     } catch { throw new Error("Unable to reach GitHub. Check your connection and try again."); }
     if (!response.ok) {
-      if (response.status === 401) throw new Error("GitHub session expired or was revoked. Please sign in again.");
+      if (response.status === 401) throw Object.assign(new Error("GitHub session expired or was revoked. Please sign in again."), { status: 401 });
       if (response.status === 429 || (response.status === 403 && (response.headers.get("x-ratelimit-remaining") === "0" || response.headers.has("retry-after")))) throw new Error("GitHub rate limit reached. Wait a few minutes and try again.");
       if (response.status === 403) throw new Error("GitHub access denied. Check app permissions and organization approval, then sign in again.");
       if (response.status === 404) throw new Error("GitHub repository or installation is unavailable. Check the repository name and app installation, then try again.");
@@ -85,7 +85,8 @@ export async function checkGitHubAccess(token: string, repo: string, appSlug: st
   };
   const rawUser = await get("/user");
   if (!rawUser || ![rawUser.login, rawUser.avatar_url, rawUser.html_url].every(value => typeof value === "string" && value)) throw new Error("GitHub returned an invalid user. Please sign in again.");
-  const user = { login: rawUser.login, avatar_url: rawUser.avatar_url, html_url: rawUser.html_url };
+  const name = typeof rawUser.name === "string" ? rawUser.name.trim() : "";
+  const user = { login: rawUser.login, ...(name ? { name } : {}), avatar_url: rawUser.avatar_url, html_url: rawUser.html_url };
   const installUrl = `https://github.com/apps/${appSlug}/installations/new`;
   const result: GitHubAccess = { user, status: "installation-required", installUrl, installation: null, repository: null };
   type Installation = { id: number; app_slug: string; account?: { login?: string }; html_url?: string; permissions?: { contents?: string }; suspended_at?: string | null };

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,10 +1 @@
-export function slugify(input: string): string {
-  return input
-    .normalize("NFKD")
-    .replace(/[̀-ͯ]/g, "") // combining marks → strip (é→e)
-    .toLowerCase()
-    .trim()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .replace(/-{2,}/g, "-");
-}
+export { slugify } from "../../slugs";

package/src/editor/lib/storage.ts

@@ -1,8 +1,36 @@
-export function readStorage(name: "settings" | "keys" | "mediaView"): string | null {
+type SessionConfig = { authOrigin: string; repo: string; branch: string; appSlug: string };
+type Session = { accessToken: string; expiresAt: number };
+
+function sessionScope(config: SessionConfig) {
+  return JSON.stringify([config.authOrigin, config.repo, config.branch, config.appSlug]);
+}
+
+export function clearSession() {
+  try { localStorage.removeItem("rigelcms.session"); } catch {}
+}
+
+export function readSession(config: SessionConfig): Session | null {
+  try {
+    const saved = JSON.parse(localStorage.getItem("rigelcms.session") ?? "null");
+    if (saved?.version === 1 && saved.scope === sessionScope(config)
+      && typeof saved.accessToken === "string" && /^ghu_[a-zA-Z0-9_]{1,4092}$/.test(saved.accessToken)
+      && Number.isSafeInteger(saved.expiresAt) && saved.expiresAt > Date.now() + 30_000 && saved.expiresAt <= Date.now() + 86_400_000) {
+      return { accessToken: saved.accessToken, expiresAt: saved.expiresAt };
+    }
+  } catch {}
+  clearSession();
+  return null;
+}
+
+export function writeSession(config: SessionConfig, session: Session) {
+  try { writeStorage("session", { version: 1, scope: sessionScope(config), accessToken: session.accessToken, expiresAt: session.expiresAt }); } catch {}
+}
+
+export function readStorage(name: "settings" | "keys" | "mediaView" | "session"): string | null {
   return localStorage.getItem(`rigelcms.${name}`) ?? localStorage.getItem(`rigel.${name}`);
 }
 
-export function writeStorage(name: "settings" | "keys" | "mediaView", value: unknown) {
+export function writeStorage(name: "settings" | "keys" | "mediaView" | "session", value: unknown) {
   localStorage.setItem(`rigelcms.${name}`, JSON.stringify(value));
   localStorage.removeItem(`rigel.${name}`);
 }

package/src/editor/lib/tooltip.ts

@@ -0,0 +1,120 @@
+export function tooltipPosition(rect: Pick<DOMRect, "left" | "right" | "top" | "bottom">, width: number, height: number, viewportWidth: number, viewportHeight: number) {
+  return {
+    left: Math.max(8, Math.min((rect.left + rect.right - width) / 2, viewportWidth - width - 8)),
+    top: Math.max(8, Math.min(rect.top >= height + 14 ? rect.top - height - 6 : rect.bottom + 6, viewportHeight - height - 8)),
+  };
+}
+
+let provider: ReturnType<typeof createTooltips> | undefined;
+
+export function tooltipRoot(root: HTMLElement) {
+  provider ??= createTooltips();
+  const remove = provider.register(root);
+  return { destroy: remove };
+}
+
+function createTooltips() {
+  let tip: HTMLDivElement | undefined;
+  let anchor: HTMLElement | null = null;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let opening: ReturnType<typeof setTimeout> | undefined;
+  let frame = 0;
+  let view: Window | null = null;
+  let pointerTime = 0;
+  let users = 0;
+  const id = "rigel-tooltip";
+
+  function hide() {
+    clearTimeout(timer);
+    clearTimeout(opening);
+    if (view) view.cancelAnimationFrame(frame);
+    if (anchor) {
+      const ids = (anchor.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(value => value && value !== id);
+      if (ids.length) anchor.setAttribute("aria-describedby", ids.join(" ")); else anchor.removeAttribute("aria-describedby");
+    }
+    anchor = null;
+    if (tip?.matches(":popover-open")) tip.hidePopover();
+    tip?.remove();
+  }
+
+  function update() {
+    if (!anchor || !tip || !view) return;
+    if (!anchor.isConnected || !anchor.checkVisibility() || !anchor.dataset.tooltip) { hide(); return; }
+    if (tip.textContent !== anchor.dataset.tooltip) tip.textContent = anchor.dataset.tooltip;
+    const position = tooltipPosition(anchor.getBoundingClientRect(), tip.offsetWidth, tip.offsetHeight, view.innerWidth, view.innerHeight);
+    tip.style.left = `${position.left}px`;
+    tip.style.top = `${position.top}px`;
+    frame = view.requestAnimationFrame(update);
+  }
+
+  function show(target: HTMLElement) {
+    hide();
+    if (!target.isConnected || !target.checkVisibility() || !target.dataset.tooltip) return;
+    const doc = target.ownerDocument;
+    tip ??= doc.createElement("div");
+    tip.id = id;
+    tip.className = "rigel-tooltip";
+    tip.setAttribute("role", "tooltip");
+    tip.popover = "manual";
+    anchor = target;
+    view = doc.defaultView;
+    const scope = target.closest("dialog, .rigel") ?? target.parentElement!;
+    scope.append(tip);
+    tip.textContent = target.dataset.tooltip;
+    target.setAttribute("aria-describedby", [...new Set([...(target.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean), id])].join(" "));
+    try { tip.showPopover(); update(); }
+    catch (error) {
+      if ((error as DOMException)?.name !== "InvalidStateError") throw error;
+      opening = setTimeout(() => { if (anchor !== target) return; if (!target.isConnected || !target.checkVisibility()) { hide(); return; } tip!.showPopover(); update(); }, 0);
+    }
+  }
+
+  function register(root: HTMLElement) {
+    users++;
+    const doc = root.ownerDocument;
+    const win = doc.defaultView!;
+    const target = (event: Event) => {
+      const element = (event.target as Element)?.closest?.<HTMLElement>("[data-tooltip]");
+      return element && root.contains(element) && element.closest(".rigel") ? element : null;
+    };
+    const over = (event: PointerEvent) => {
+      if (event.pointerType === "touch") return;
+      if (event.target === tip) { clearTimeout(timer); return; }
+      const element = target(event);
+      if (!element || element.contains(event.relatedTarget as Node | null) || element === anchor || element === doc.activeElement) return;
+      hide(); timer = setTimeout(() => show(element), 450);
+    };
+    const out = (event: PointerEvent) => {
+      const element = target(event);
+      if (element?.contains(event.relatedTarget as Node | null)) return;
+      if (event.relatedTarget === tip || anchor?.contains(event.relatedTarget as Node | null)) return;
+      if (anchor === doc.activeElement) return;
+      clearTimeout(timer); timer = setTimeout(hide, 150);
+    };
+    const focus = (event: FocusEvent) => {
+      const element = target(event);
+      if (element && Date.now() - pointerTime > 700) show(element);
+    };
+    const down = () => { pointerTime = Date.now(); hide(); };
+    const key = (event: KeyboardEvent) => {
+      pointerTime = 0;
+      if (event.key !== "Escape") return;
+      const visible = !!anchor;
+      hide();
+      if (visible) { event.preventDefault(); event.stopImmediatePropagation(); }
+    };
+    const listeners = [["pointerover", over], ["pointerout", out], ["focusin", focus], ["focusout", hide], ["pointerdown", down], ["click", hide], ["keydown", key]] as const;
+    for (const [name, listener] of listeners) root.addEventListener(name, listener as EventListener, true);
+    win.addEventListener("blur", hide);
+    win.addEventListener("resize", hide);
+    win.addEventListener("scroll", hide, true);
+    return () => {
+      hide();
+      for (const [name, listener] of listeners) root.removeEventListener(name, listener as EventListener, true);
+      win.removeEventListener("blur", hide); win.removeEventListener("resize", hide);
+      win.removeEventListener("scroll", hide, true);
+      if (!--users) { tip = undefined; provider = undefined; }
+    };
+  }
+  return { register };
+}