@drawnagency/primitives 0.1.48 → 0.1.50

package/src/hooks/useEditorPublish.ts

@@ -2,7 +2,7 @@ import { useState, useCallback, useRef, useEffect } from "react";
 import type { SiteIndex, SiteConfig } from "../schemas/site-config";
 import type { LoadedSection } from "../lib/loader";
 import type { MediaManifest, MediaItem } from "../media/types";
-import { getDirtySectionRows, hasLocalChanges, discardSavedChanges, cacheContent, getPendingMediaBlobs, clearPendingMedia } from "../lib/dexie";
+import { getDirtySectionRows, hasLocalChanges, discardSavedChanges, cacheContent, getPendingMediaBlobs, clearPendingMediaByIds } from "../lib/dexie";
 
 function blobToBase64(blob: Blob): Promise<string> {
   return new Promise((resolve, reject) => {
@@ -140,7 +140,7 @@ export function useEditorPublish({
     pendingMediaDeletions: string[];
     mediaManifest: MediaManifest;
     manifestDirty: boolean;
-  }): Promise<{ sha: string; savedSections: { sectionId: string; updatedAt: string }[] }> {
+  }): Promise<{ sha: string; savedSections: { sectionId: string; updatedAt: string }[]; uploadedItems: MediaItem[] }> {
     const dirty = await getDirtySectionRows();
     const gathered = await gatherMediaPayload(
       args.pendingMediaItems,
@@ -158,7 +158,7 @@ export function useEditorPublish({
       }
       siteIndex = {
         ...siteIndex,
-        order: siteIndex.order.filter((id) => !deleteSet.has(id)),
+        pages: siteIndex.pages.map((p) => ({ ...p, order: p.order.filter((id) => !deleteSet.has(id)) })),
         sections: filteredSections,
       };
     }
@@ -199,6 +199,10 @@ export function useEditorPublish({
     return {
       sha: responseData.sha as string,
       savedSections: dirty.map(({ sectionId, updatedAt }) => ({ sectionId, updatedAt })),
+      // Only the items whose blobs were actually written to GitHub. Items skipped
+      // by gatherMediaPayload (blobs not yet persisted) are excluded so the caller
+      // never promotes them into the manifest as orphans.
+      uploadedItems: gathered.mediaUploads.map(({ item }) => item),
     };
   }
 
@@ -221,7 +225,7 @@ export function useEditorPublish({
         return;
       }
 
-      const { sha, savedSections } = await performSave({
+      const { sha, savedSections, uploadedItems } = await performSave({
         siteConfig, siteIndexRef, deletedSectionIds,
         isConfigDirty, pendingMediaItems, pendingMediaDeletions, mediaManifest, manifestDirty,
       });
@@ -230,11 +234,14 @@ export function useEditorPublish({
       // during the request) and invalidates contentCache so a reload reflects
       // the just-saved content instead of showing the stale pre-save snapshot.
       await discardSavedChanges(savedSections);
-      await clearPendingMedia();
+      // Promote/clear only the media that was actually committed. Items skipped
+      // because their blobs weren't persisted stay pending and retry next save —
+      // promoting them here would create manifest orphans (no backing file).
+      await clearPendingMediaByIds(uploadedItems.map((i) => i.id), pendingMediaDeletions);
       clearConfigDirty();
       clearManifestDirty();
       onSuccess();
-      onMediaPublished(pendingMediaItems, pendingMediaDeletions);
+      onMediaPublished(uploadedItems, pendingMediaDeletions);
       onShasUpdated(sha, null);
 
       showFeedback("Saved", 3000);
@@ -295,8 +302,9 @@ export function useEditorPublish({
       const hasLocalEdits = hasChanges || isConfigDirty() || hasMediaChanges || hasDeletedSections;
 
       let savedSections: { sectionId: string; updatedAt: string }[] = [];
+      let uploadedItems: MediaItem[] = [];
       if (hasLocalEdits) {
-        ({ savedSections } = await performSave({
+        ({ savedSections, uploadedItems } = await performSave({
           siteConfig, siteIndexRef, deletedSectionIds,
           isConfigDirty, pendingMediaItems, pendingMediaDeletions, mediaManifest, manifestDirty,
         }));
@@ -322,12 +330,12 @@ export function useEditorPublish({
 
       if (hasLocalEdits) {
         await discardSavedChanges(savedSections);
-        await clearPendingMedia();
+        await clearPendingMediaByIds(uploadedItems.map((i) => i.id), pendingMediaDeletions);
         await cacheContent(sha, sections, siteIndexRef.current, siteConfig);
         clearConfigDirty();
         clearManifestDirty();
         onSuccess();
-        onMediaPublished(pendingMediaItems, pendingMediaDeletions);
+        onMediaPublished(uploadedItems, pendingMediaDeletions);
       }
 
       onShasUpdated(null, sha);

package/src/hooks/useMediaPipeline.ts

@@ -96,7 +96,7 @@ export function useMediaPipeline({
           const kind = event.item.kind;
           const sanitizedName = sanitizeMediaName(event.item.originalName);
 
-          const finalize = (
+          const finalize = async (
             localUrls: Record<string, string>,
             blobsMap: Record<string, Blob>,
             width: number,
@@ -121,7 +121,19 @@ export function useMediaPipeline({
               alt: "",
             };
 
-            addPendingMediaItem(item, localUrls, blobsMap);
+            try {
+              // Persist blobs to IndexedDB BEFORE marking the item pending.
+              // Previously this was fire-and-forget: a Save firing before the
+              // write landed — or a failed write (e.g. storage quota) — left the
+              // item promoted into the manifest with no backing file, an orphan
+              // that dropped out on the next render and blocked re-adding it.
+              await addPendingMediaItem(item, localUrls, blobsMap);
+            } catch (err) {
+              console.error(`[useMediaPipeline] Failed to persist media "${item.originalName}":`, err);
+              for (const url of Object.values(localUrls)) URL.revokeObjectURL(url);
+              return;
+            }
+            if (destroyedRef.current) return;
             removePendingMediaDeletion(item.id);
             setPendingDeletions((prev) => prev.filter((d) => d !== item.id));
             setPendingMediaItems((prev) => [...prev, item]);
@@ -156,10 +168,10 @@ export function useMediaPipeline({
               ({ posterBlob, width, height }) => {
                 blobsMap["poster"] = posterBlob;
                 localUrls["poster"] = URL.createObjectURL(posterBlob);
-                finalize(localUrls, blobsMap, width, height);
+                void finalize(localUrls, blobsMap, width, height);
               },
               () => {
-                finalize(localUrls, blobsMap, result.width, result.height);
+                void finalize(localUrls, blobsMap, result.width, result.height);
               },
             );
           } else {
@@ -167,7 +179,7 @@ export function useMediaPipeline({
               blobsMap["poster"] = result.posterBlob;
               localUrls["poster"] = URL.createObjectURL(result.posterBlob);
             }
-            finalize(localUrls, blobsMap, result.width, result.height);
+            void finalize(localUrls, blobsMap, result.width, result.height);
           }
         }
       },

package/src/lib/dexie.ts

@@ -1,6 +1,6 @@
 import Dexie from "dexie";
 import type { SectionContent } from "../schemas/sections";
-import type { SiteIndex, SectionMeta, SiteConfig } from "../schemas/site-config";
+import type { SiteIndex, SectionMeta, SiteConfig, Page } from "../schemas/site-config";
 import type { LoadedSection } from "./loader";
 import type { MediaManifest, MediaItem } from "../media/types";
 
@@ -13,7 +13,7 @@ interface SectionRow {
 
 interface SiteIndexRow {
   key: string;
-  order: string[];
+  pages: Page[];
   sections: Record<string, SectionMeta>;
   deletedSections: string[];
   updatedAt: string;
@@ -123,6 +123,19 @@ class EditorDatabase extends Dexie {
     }).upgrade((tx) => {
       return tx.table("pendingMedia").clear();
     });
+    this.version(7).stores({
+      sections: "sectionId",
+      siteIndex: "key",
+      meta: "key",
+      siteConfig: "key",
+      contentCache: "key",
+      mediaManifest: "key",
+      pendingMedia: "id",
+      pendingMediaDeletions: "id",
+    }).upgrade(async (tx) => {
+      await tx.table("siteIndex").clear();
+      await tx.table("contentCache").clear();
+    });
   }
 }
 
@@ -173,7 +186,7 @@ export async function restoreLocalChanges(): Promise<{
     const siteId = metaRow?.siteId ?? "";
     return {
       sections,
-      siteIndex: { siteId, order: indexRow.order, sections: indexRow.sections },
+      siteIndex: { siteId, pages: indexRow.pages, sections: indexRow.sections },
       siteConfig: configRow?.config,
       deletedSections: indexRow.deletedSections ?? [],
     };
@@ -200,7 +213,7 @@ export async function persistSiteIndex(index: SiteIndex, deletedSections: string
   await database.transaction("rw", [database.siteIndex, database.meta], async () => {
     await database.siteIndex.put({
       key: "current",
-      order: index.order,
+      pages: index.pages,
       sections: index.sections,
       deletedSections,
       updatedAt: now,
@@ -323,7 +336,7 @@ export async function persistAll(
       if (siteIndex) {
         await database.siteIndex.put({
           key: "current",
-          order: siteIndex.order,
+          pages: siteIndex.pages,
           sections: siteIndex.sections,
           deletedSections: [],
           updatedAt: now,
@@ -463,3 +476,19 @@ export async function clearPendingMedia(): Promise<void> {
     await database.pendingMediaDeletions.clear();
   });
 }
+
+// Clears only the pending uploads and deletions that were actually committed in
+// a save. Items skipped during the save (e.g. their blobs hadn't finished
+// writing to IndexedDB) are left in place so the next save retries them, instead
+// of being wiped and promoted into the manifest as orphans with no backing file.
+export async function clearPendingMediaByIds(
+  itemIds: string[],
+  deletionIds: string[],
+): Promise<void> {
+  if (itemIds.length === 0 && deletionIds.length === 0) return;
+  const database = getDb();
+  await database.transaction("rw", [database.pendingMedia, database.pendingMediaDeletions], async () => {
+    if (itemIds.length > 0) await database.pendingMedia.bulkDelete(itemIds);
+    if (deletionIds.length > 0) await database.pendingMediaDeletions.bulkDelete(deletionIds);
+  });
+}

package/src/lib/events.ts

@@ -1,4 +1,4 @@
-import type { NavItem } from "./nav";
+import type { NavItem, SiteNav } from "./nav";
 
 export interface TypedEvent<T> {
   dispatch(detail: T): void;
@@ -22,3 +22,5 @@ export const editModeEvent = createEvent<{ isEditMode: boolean }>("editmodechang
 export const navChangeEvent = createEvent<NavItem[]>("sitenavchange");
 export const darkModeEvent = createEvent<string>("sitedarkmode");
 export const historySelectEvent = createEvent<{ sha: string; date: string }>("history-select");
+export const siteNavChangeEvent = createEvent<SiteNav>("sitenavchange-v2");
+export const pageSelectEvent = createEvent<string>("pageselect");

package/src/lib/links.ts

@@ -0,0 +1,41 @@
+import type { SiteIndex } from "../schemas/site-config";
+import type { Section } from "../schemas/sections";
+import type { LinkValue } from "../schemas/link";
+import { pageById } from "./pages";
+import { toSectionId } from "./nav";
+
+export function resolveLinkHref(
+  link: LinkValue,
+  index: SiteIndex,
+  headingById: Record<string, string | undefined>,
+): { href: string; target: string } {
+  if (link.kind === "external") return { href: link.href, target: link.target };
+
+  const page = pageById(index, link.pageId);
+  if (!page) return { href: "", target: link.target };
+  let href = page.slug === "" ? "/" : `/${page.slug}`;
+  if (link.anchorSectionId) {
+    const heading = headingById[link.anchorSectionId];
+    if (heading) href += `#${toSectionId(heading)}`;
+  }
+  return { href, target: link.target };
+}
+
+/**
+ * Rewrite any internal LinkValue embedded in a section's content into a
+ * resolved external link so the zero-JS viewer renders a plain <a>. Currently
+ * the only link-bearing field is the button section's `content.link`.
+ */
+export function resolveInternalLinks(
+  section: Section,
+  index: SiteIndex,
+  headingById: Record<string, string | undefined>,
+): Section {
+  const content = section.content as { link?: LinkValue } | undefined;
+  if (!content?.link || content.link.kind !== "internal") return section;
+  const resolved = resolveLinkHref(content.link, index, headingById);
+  return {
+    ...section,
+    content: { ...content, link: { kind: "external", href: resolved.href, target: resolved.target } },
+  };
+}

package/src/lib/loader.ts

@@ -15,7 +15,7 @@ export interface SiteContent {
 /**
  * Merge a validated index with raw section file contents.
  * Validates each section file against its Zod schema.
- * Returns sections in the order specified by index.order.
+ * Returns sections in the concatenated order of every page's order.
  */
 export function mergeSiteContent(
   index: SiteIndex,
@@ -26,7 +26,8 @@ export function mergeSiteContent(
   const canValidate = getAllSchemas().length >= 2;
   const schema = canValidate ? getSectionSchema() : null;
 
-  for (const id of index.order) {
+  const orderedIds = index.pages.flatMap((p) => p.order);
+  for (const id of orderedIds) {
     const raw = sectionFiles[id];
     if (!raw) {
       console.warn(`Section file missing for id: ${id}, skipping`);
@@ -53,7 +54,7 @@ export function mergeSiteContent(
 /**
  * Build a SiteContent from a Vite `import.meta.glob` result.
  * Callers glob the section JSON files at build time, pass the parsed index, and
- * receive sections merged in index.order.
+ * receive sections merged across every page's order.
  */
 export function loadStaticSiteContent(
   index: SiteIndex,
@@ -81,7 +82,7 @@ export async function loadSiteContent(contentDir: string): Promise<SiteContent>
   const index = IndexSchema.parse(indexRaw);
 
   const sectionFiles: Record<string, unknown> = {};
-  for (const id of index.order) {
+  for (const id of index.pages.flatMap((p: SiteIndex["pages"][number]) => p.order)) {
     const sectionPath = path.join(contentDir, "sections", `${id}.json`);
     sectionFiles[id] = JSON.parse(await fs.readFile(sectionPath, "utf-8"));
   }

package/src/lib/nav.ts

@@ -1,5 +1,7 @@
 import type { LoadedSection } from "./loader";
 import { getSection, type SectionRegistry } from "./registry";
+import { audiencePasses, homePage, pageDisplayTitle } from "./pages";
+import type { SiteIndex } from "../schemas/site-config";
 
 export interface NavItem {
   href: string;
@@ -81,3 +83,60 @@ export function generateNavLinks(
 
   return nav;
 }
+
+export interface PageNavItem {
+  id: string;
+  title: string;
+  href: string;
+  slug: string;
+  isActive: boolean;
+  headings: NavItem[];
+}
+
+export interface SiteNav {
+  pages: PageNavItem[];
+  /** Live pages with showInNav off — editor-only group, like the archive. */
+  hidden: PageNavItem[];
+  archive: PageNavItem[];
+}
+
+function pageHref(slug: string): string {
+  return slug === "" ? "/" : `/${slug}`;
+}
+
+export function generateSiteNav(opts: {
+  index: SiteIndex;
+  activeSections: LoadedSection[];
+  activePageId: string | null;
+  mode: "viewer" | "editor";
+  audience: string | null;
+  registry?: SectionRegistry;
+}): SiteNav {
+  const { index, activeSections, activePageId, mode, audience, registry } = opts;
+  const active = activePageId ?? homePage(index).id;
+
+  const toNavItem = (p: (typeof index.pages)[number]): PageNavItem => ({
+    id: p.id,
+    title: pageDisplayTitle(p.title),
+    href: pageHref(p.slug),
+    slug: p.slug,
+    isActive: p.id === active,
+    headings: p.id === active ? generateNavLinks(activeSections, registry) : [],
+  });
+
+  if (mode === "editor") {
+    return {
+      pages: index.pages.filter((p) => p.status === "live" && p.showInNav).map(toNavItem),
+      hidden: index.pages.filter((p) => p.status === "live" && !p.showInNav).map(toNavItem),
+      archive: index.pages.filter((p) => p.status === "archived").map(toNavItem),
+    };
+  }
+
+  return {
+    pages: index.pages
+      .filter((p) => p.status === "live" && p.showInNav && audiencePasses(p.access, audience))
+      .map(toNavItem),
+    hidden: [],
+    archive: [],
+  };
+}

package/src/lib/pages.ts

@@ -0,0 +1,209 @@
+import type { Page, SiteIndex, SectionMeta } from "../schemas/site-config";
+import { RESERVED_SLUGS } from "../schemas/site-config";
+
+/**
+ * Display fallback for blank page titles. addPage creates pages with an empty
+ * title (the editor prompts for one), and closing the modal can leave it blank
+ * — every UI that renders a page title must go through this.
+ */
+export function pageDisplayTitle(title: string): string {
+  return title || "Untitled";
+}
+
+export function slugifyPageSlug(input: string): string {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+export function uniquePageSlug(base: string, existing: string[]): string {
+  const taken = new Set(existing);
+  const reserved = new Set<string>(RESERVED_SLUGS);
+  let candidate = base || "page";
+  if (!taken.has(candidate) && !reserved.has(candidate)) return candidate;
+  let n = 2;
+  while (taken.has(`${candidate}-${n}`) || reserved.has(`${candidate}-${n}`)) n++;
+  return `${candidate}-${n}`;
+}
+
+export function pageById(index: SiteIndex, id: string): Page | undefined {
+  return index.pages.find((p) => p.id === id);
+}
+
+export function homePage(index: SiteIndex): Page {
+  return index.pages.find((p) => p.isHome) ?? index.pages[0];
+}
+
+export function pageBySlug(index: SiteIndex, slug: string): Page | undefined {
+  const normalized = slug.replace(/^\/+|\/+$/g, "");
+  if (normalized === "") return homePage(index);
+  return index.pages.find((p) => p.slug === normalized);
+}
+
+export function audiencePasses(access: string[], audience: string | null): boolean {
+  if (access.length === 0) return true;
+  if (!audience) return true;
+  return access.includes(audience);
+}
+
+function mapPages(index: SiteIndex, fn: (p: Page) => Page): SiteIndex {
+  return { ...index, pages: index.pages.map(fn) };
+}
+
+export function addPage(index: SiteIndex, id: string): SiteIndex {
+  // Title starts blank (the editor prompts for it); the slug must stay valid and
+  // unique in the stored index, so it gets a placeholder until the title is typed.
+  const slug = uniquePageSlug("new-page", index.pages.map((p) => p.slug));
+  const page: Page = {
+    id, title: "", slug, isHome: false, showInNav: true, status: "live", access: [], order: [],
+  };
+  return { ...index, pages: [...index.pages, page] };
+}
+
+export function reorderPages(index: SiteIndex, fromIndex: number, toIndex: number): SiteIndex {
+  const len = index.pages.length;
+  if (fromIndex < 0 || fromIndex >= len || toIndex < 0 || toIndex >= len) return index;
+  const pages = [...index.pages];
+  const [moved] = pages.splice(fromIndex, 1);
+  pages.splice(toIndex, 0, moved);
+  return { ...index, pages };
+}
+
+export function setHomePage(index: SiteIndex, pageId: string): SiteIndex {
+  const current = homePage(index);
+  if (current.id === pageId) return index;
+  if (!pageById(index, pageId)) return index;
+  const existingSlugs = index.pages.map((p) => p.slug);
+  const demotedSlug = uniquePageSlug(slugifyPageSlug(current.title) || "home", existingSlugs.filter((s) => s !== ""));
+  return mapPages(index, (p) => {
+    if (p.id === pageId) return { ...p, isHome: true, slug: "" };
+    if (p.id === current.id) return { ...p, isHome: false, slug: demotedSlug };
+    return { ...p, isHome: false };
+  });
+}
+
+export function setPageArchived(index: SiteIndex, pageId: string, archived: boolean): SiteIndex {
+  return mapPages(index, (p) => {
+    if (p.id !== pageId) return p;
+    if (p.isHome && archived) return p;
+    return { ...p, status: archived ? "archived" : "live" };
+  });
+}
+
+export function setPageFields(
+  index: SiteIndex,
+  pageId: string,
+  patch: Partial<Pick<Page, "title" | "slug" | "showInNav">>,
+): SiteIndex {
+  return mapPages(index, (p) => (p.id === pageId ? { ...p, ...patch } : p));
+}
+
+export function setPageAudience(
+  index: SiteIndex,
+  pageId: string,
+  access: string[],
+): { index: SiteIndex; resetSectionIds: string[] } {
+  const page = pageById(index, pageId);
+  if (!page) return { index, resetSectionIds: [] };
+  const removed = page.access.filter((a) => !access.includes(a));
+  const nextPages = index.pages.map((p) => (p.id === pageId ? { ...p, access } : p));
+
+  const resetSectionIds: string[] = [];
+  const nextSections: Record<string, SectionMeta> = { ...index.sections };
+  if (removed.length > 0) {
+    for (const sectionId of page.order) {
+      const meta = nextSections[sectionId];
+      if (meta && meta.access.some((a) => removed.includes(a))) {
+        nextSections[sectionId] = { ...meta, access: [] };
+        resetSectionIds.push(sectionId);
+      }
+    }
+  }
+  return { index: { ...index, pages: nextPages, sections: nextSections }, resetSectionIds };
+}
+
+export function deletePage(
+  index: SiteIndex,
+  pageId: string,
+): { index: SiteIndex; removedSectionIds: string[] } {
+  const page = pageById(index, pageId);
+  if (!page || page.isHome) return { index, removedSectionIds: [] };
+  const removedSectionIds = [...page.order];
+  const nextSections: Record<string, SectionMeta> = { ...index.sections };
+  for (const id of removedSectionIds) delete nextSections[id];
+  return {
+    index: { ...index, pages: index.pages.filter((p) => p.id !== pageId), sections: nextSections },
+    removedSectionIds,
+  };
+}
+
+export function addSectionToPage(
+  index: SiteIndex,
+  pageId: string,
+  sectionId: string,
+  meta: SectionMeta,
+  insertIndex: number,
+): SiteIndex {
+  const pages = index.pages.map((p) => {
+    if (p.id !== pageId) return p;
+    const order = [...p.order];
+    order.splice(insertIndex, 0, sectionId);
+    return { ...p, order };
+  });
+  return { ...index, pages, sections: { ...index.sections, [sectionId]: meta } };
+}
+
+export function removeSectionFromPages(index: SiteIndex, sectionId: string): SiteIndex {
+  const pages = index.pages.map((p) =>
+    p.order.includes(sectionId) ? { ...p, order: p.order.filter((id) => id !== sectionId) } : p,
+  );
+  const sections = { ...index.sections };
+  delete sections[sectionId];
+  return { ...index, pages, sections };
+}
+
+export function reorderSectionInPage(
+  index: SiteIndex,
+  pageId: string,
+  fromIndex: number,
+  toIndex: number,
+): SiteIndex {
+  const pages = index.pages.map((p) => {
+    if (p.id !== pageId) return p;
+    const len = p.order.length;
+    if (fromIndex < 0 || fromIndex >= len || toIndex < 0 || toIndex >= len) return p;
+    const order = [...p.order];
+    const [moved] = order.splice(fromIndex, 1);
+    order.splice(toIndex, 0, moved);
+    return { ...p, order };
+  });
+  return { ...index, pages };
+}
+
+export function moveSection(
+  index: SiteIndex,
+  sectionId: string,
+  destPageId: string,
+  position: "top" | "bottom",
+): SiteIndex {
+  const dest = pageById(index, destPageId);
+  if (!dest) return index;
+  if (!index.sections[sectionId]) return index;
+  const pages = index.pages.map((p) => {
+    if (p.order.includes(sectionId)) p = { ...p, order: p.order.filter((id) => id !== sectionId) };
+    if (p.id === destPageId) {
+      const order = [...p.order];
+      if (position === "top") order.unshift(sectionId);
+      else order.push(sectionId);
+      p = { ...p, order };
+    }
+    return p;
+  });
+
+  // Cascade: if the destination declares audiences and the section carries any
+  // audience not allowed there, reset it to "No Audience".
+  let sections = index.sections;
+  const meta = index.sections[sectionId];
+  if (meta && dest.access.length > 0 && meta.access.some((a) => !dest.access.includes(a))) {
+    sections = { ...index.sections, [sectionId]: { ...meta, access: [] } };
+  }
+  return { ...index, pages, sections };
+}

package/src/lib/registry.ts

@@ -1,6 +1,7 @@
 import type { ZodType, z } from "zod";
 import type { ComponentType, ReactNode } from "react";
 import type { Audience } from "../schemas/auth";
+import type { LinkValue } from "../schemas/link";
 
 // --- Settings field types ---
 
@@ -42,6 +43,12 @@ export type SettingsFieldDef =
       min: number;
       max: number;
       step?: number;
+    }
+  | {
+      type: "link";
+      label: string;
+      default: LinkValue;
+      target?: "content" | "options";
     };
 
 export type SettingsSchema = Record<string, SettingsFieldDef>;
@@ -82,6 +89,7 @@ export interface WrapperProps {
   onReorder?: (fromIndex: number, toIndex: number) => void;
   onRequestInsert?: (index: number) => void;
   onDelete?: () => void;
+  onMoveSection?: () => void;
   mainStatus?: string | null;
   contentDiffersFromMain?: boolean;
   isLocalOnly?: boolean;

package/src/schemas/index.ts

@@ -5,3 +5,4 @@ export * from "./media";
 export * from "./audience";
 export * from "./media-grid-options";
 export * from "./auth";
+export * from "./link";

package/src/schemas/link.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+export const LinkTargetSchema = z.enum(["_self", "_blank"]);
+
+export const LinkValueSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("external"), href: z.string(), target: LinkTargetSchema }),
+  z.object({
+    kind: z.literal("internal"),
+    pageId: z.string(),
+    anchorSectionId: z.string().nullable().optional(),
+    target: LinkTargetSchema,
+  }),
+]);
+
+export type LinkValue = z.infer<typeof LinkValueSchema>;
+
+export const DEFAULT_LINK: LinkValue = { kind: "external", href: "", target: "_self" };