mdorigin 0.1.0 → 0.1.1

package/README.md

@@ -2,15 +2,21 @@
 
 `mdorigin` is a markdown-first publishing engine.
 
-It treats markdown as the only source of truth, serves raw `.md` directly for agents, and renders `.html` views for humans from the same directory tree.
+It treats markdown as the only source of truth, serves raw `.md` directly for agents, renders `.html` views for humans from the same directory tree, can return markdown from extensionless routes when clients send `Accept: text/markdown`, and supports frontmatter aliases for old URL redirects.
 
 ## Install
 
 ```bash
-npm install mdorigin
+npm install --save-dev mdorigin
 ```
 
-## Development
+Then run it with `npx`:
+
+```bash
+npx mdorigin dev --root docs/site
+```
+
+## Repo Development
 
 ```bash
 npm install

package/dist/adapters/cloudflare.js

@@ -24,15 +24,23 @@ export function createCloudflareWorker(manifest) {
                 draftMode: 'exclude',
                 siteConfig: manifest.siteConfig ?? {
                     siteTitle: 'mdorigin',
+                    siteUrl: undefined,
+                    favicon: undefined,
+                    logo: undefined,
                     showDate: true,
                     showSummary: true,
                     theme: 'paper',
                     template: 'document',
                     topNav: [],
+                    footerNav: [],
+                    footerText: undefined,
+                    socialLinks: [],
+                    editLink: undefined,
                     showHomeIndex: true,
                     siteTitleConfigured: false,
                     siteDescriptionConfigured: false,
                 },
+                acceptHeader: request.headers.get('accept') ?? undefined,
             });
             const headers = new Headers(siteResponse.headers);
             const body = siteResponse.body instanceof Uint8Array

package/dist/adapters/node.js

@@ -86,6 +86,7 @@ export function createNodeRequestListener(options) {
             const siteResponse = await handleSiteRequest(store, url.pathname, {
                 draftMode: options.draftMode,
                 siteConfig: options.siteConfig,
+                acceptHeader: request.headers.accept,
             });
             response.statusCode = siteResponse.status;
             for (const [headerName, headerValue] of Object.entries(siteResponse.headers)) {

package/dist/cli/main.d.ts

@@ -1 +1,2 @@
+#!/usr/bin/env node
 export {};

package/dist/cli/main.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { runBuildIndexCommand } from './build-index.js';
 import { runBuildCloudflareCommand } from './build-cloudflare.js';
 import { runDevCommand } from './dev.js';

package/dist/core/markdown.d.ts

@@ -5,6 +5,7 @@ export interface ParsedDocumentMeta {
     draft?: boolean;
     type?: string;
     order?: number;
+    aliases?: string[];
     [key: string]: unknown;
 }
 export interface ParsedDocument {
@@ -13,8 +14,15 @@ export interface ParsedDocument {
     html: string;
     meta: ParsedDocumentMeta;
 }
+export interface ManagedIndexEntry {
+    kind: 'directory' | 'article';
+    title: string;
+    href: string;
+    detail?: string;
+}
 export declare function parseMarkdownDocument(sourcePath: string, markdown: string): Promise<ParsedDocument>;
 export declare function renderMarkdown(markdown: string): Promise<string>;
 export declare function rewriteMarkdownLinksInHtml(html: string): string;
 export declare function stripManagedIndexBlock(markdown: string): string;
 export declare function stripManagedIndexLinks(markdown: string, hrefs: ReadonlySet<string>): string;
+export declare function extractManagedIndexEntries(markdown: string): ManagedIndexEntry[];

package/dist/core/markdown.js

@@ -49,6 +49,35 @@ export function stripManagedIndexLinks(markdown, hrefs) {
         return `${start}${keptBlocks.join('\n\n')}\n${end}`;
     });
 }
+export function extractManagedIndexEntries(markdown) {
+    const match = markdown.match(/<!-- INDEX:START -->\n?([\s\S]*?)\n?<!-- INDEX:END -->/);
+    if (!match) {
+        return [];
+    }
+    const blocks = match[1]
+        .trim()
+        .split(/\n\s*\n/g)
+        .map((block) => block.trim())
+        .filter((block) => block !== '');
+    const entries = [];
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        const firstLine = lines[0]?.trim() ?? '';
+        const entryMatch = firstLine.match(/^- \[([^\]]+)\]\(([^)]+)\)$/);
+        if (!entryMatch) {
+            continue;
+        }
+        const rawHref = entryMatch[2];
+        const href = rewriteMarkdownHref(rawHref);
+        entries.push({
+            kind: href.endsWith('/') ? 'directory' : 'article',
+            title: entryMatch[1],
+            href,
+            detail: lines[1]?.trim() || undefined,
+        });
+    }
+    return entries;
+}
 function normalizeMeta(data) {
     const meta = { ...data };
     if (typeof data.title === 'string') {
@@ -78,6 +107,12 @@ function normalizeMeta(data) {
             meta.order = order;
         }
     }
+    if (typeof data.aliases === 'string' && data.aliases !== '') {
+        meta.aliases = [data.aliases];
+    }
+    if (Array.isArray(data.aliases)) {
+        meta.aliases = data.aliases.filter((value) => typeof value === 'string' && value !== '');
+    }
     return meta;
 }
 function rewriteMarkdownHref(href) {

package/dist/core/request-handler.d.ts

@@ -3,6 +3,7 @@ import type { ResolvedSiteConfig } from './site-config.js';
 export interface HandleSiteRequestOptions {
     draftMode: 'include' | 'exclude';
     siteConfig: ResolvedSiteConfig;
+    acceptHeader?: string;
 }
 export interface SiteResponse {
     status: number;

package/dist/core/request-handler.js

@@ -1,16 +1,36 @@
 import path from 'node:path';
 import { inferDirectoryContentType } from './content-type.js';
 import { getDirectoryIndexCandidates } from './directory-index.js';
-import { parseMarkdownDocument, stripManagedIndexBlock, stripManagedIndexLinks, } from './markdown.js';
-import { resolveRequest } from './router.js';
+import { extractManagedIndexEntries, parseMarkdownDocument, stripManagedIndexBlock, stripManagedIndexLinks, } from './markdown.js';
+import { normalizeRequestPath, resolveRequest } from './router.js';
 import { escapeHtml, renderDocument } from '../html/template.js';
 export async function handleSiteRequest(store, pathname, options) {
+    if (pathname === '/sitemap.xml') {
+        return renderSitemap(store, options);
+    }
     const resolved = resolveRequest(pathname);
+    const negotiatedMarkdown = shouldServeMarkdownForRequest(resolved, options.acceptHeader);
     if (resolved.kind === 'not-found' || !resolved.sourcePath) {
+        const aliasRedirect = await tryRedirectAlias(store, pathname, options);
+        if (aliasRedirect !== null) {
+            return aliasRedirect;
+        }
         return notFound();
     }
     const entry = await store.get(resolved.sourcePath);
     if (entry === null) {
+        const aliasRedirect = await tryRedirectAlias(store, pathname, options);
+        if (aliasRedirect !== null) {
+            return aliasRedirect;
+        }
+        const alternateDirectoryMarkdown = await tryServeAlternateDirectoryMarkdown(store, resolved, options, negotiatedMarkdown);
+        if (alternateDirectoryMarkdown !== null) {
+            return alternateDirectoryMarkdown;
+        }
+        const alternateMarkdownRedirect = await tryRedirectAlternateDirectoryMarkdown(store, resolved, options);
+        if (alternateMarkdownRedirect !== null) {
+            return alternateMarkdownRedirect;
+        }
         if (resolved.kind === 'html' && resolved.requestPath.endsWith('/')) {
             const directoryIndexResponse = await tryRenderAlternateDirectoryIndex(store, resolved.requestPath, options);
             if (directoryIndexResponse !== null) {
@@ -26,16 +46,16 @@ export async function handleSiteRequest(store, pathname, options) {
     if (entry.kind !== 'text' || entry.text === undefined) {
         return notFound();
     }
-    if (resolved.kind === 'markdown') {
+    if (resolved.kind === 'markdown' || negotiatedMarkdown) {
         const parsed = await parseMarkdownDocument(resolved.sourcePath, entry.text);
         if (parsed.meta.draft === true && options.draftMode === 'exclude') {
             return notFound();
         }
         return {
             status: 200,
-            headers: {
+            headers: withVaryAcceptIfNeeded({
                 'content-type': entry.mediaType,
-            },
+            }, negotiatedMarkdown),
             body: entry.text,
         };
     }
@@ -49,17 +69,26 @@ export async function handleSiteRequest(store, pathname, options) {
         : isRootHomeRequest(resolved.requestPath) && navigation.items.length > 0
             ? stripManagedIndexLinks(entry.text, new Set(navigation.items.map((item) => item.href)))
             : entry.text;
-    const renderedParsed = renderedBody === entry.text
+    const catalogEntries = options.siteConfig.template === 'catalog'
+        ? extractManagedIndexEntries(renderedBody)
+        : [];
+    const documentBody = options.siteConfig.template === 'catalog'
+        ? stripManagedIndexBlock(renderedBody)
+        : renderedBody;
+    const renderedParsed = documentBody === entry.text
         ? parsed
-        : await parseMarkdownDocument(resolved.sourcePath, renderedBody);
+        : await parseMarkdownDocument(resolved.sourcePath, documentBody);
     return {
         status: 200,
-        headers: {
+        headers: withVaryAcceptIfNeeded({
             'content-type': 'text/html; charset=utf-8',
-        },
+        }, shouldVaryOnAccept(resolved)),
         body: renderDocument({
             siteTitle: options.siteConfig.siteTitle,
             siteDescription: options.siteConfig.siteDescription,
+            siteUrl: options.siteConfig.siteUrl,
+            favicon: options.siteConfig.favicon,
+            logo: options.siteConfig.logo,
             title: getDocumentTitle(parsed),
             body: renderedParsed.html,
             summary: options.siteConfig.showSummary === false ? undefined : parsed.meta.summary,
@@ -69,7 +98,14 @@ export async function handleSiteRequest(store, pathname, options) {
             theme: options.siteConfig.theme,
             template: options.siteConfig.template,
             topNav: navigation.items,
+            footerNav: options.siteConfig.footerNav,
+            footerText: options.siteConfig.footerText,
+            socialLinks: options.siteConfig.socialLinks,
+            editLinkHref: getEditLinkHref(options.siteConfig, resolved.sourcePath),
             stylesheetContent: options.siteConfig.stylesheetContent,
+            canonicalPath: getCanonicalHtmlPathForContentPath(resolved.sourcePath),
+            alternateMarkdownPath: getMarkdownRequestPathForContentPath(resolved.sourcePath),
+            catalogEntries,
         }),
     };
 }
@@ -103,6 +139,61 @@ function notFound() {
         body: 'Not Found',
     };
 }
+function redirect(location) {
+    return {
+        status: 308,
+        headers: {
+            location,
+        },
+    };
+}
+async function renderSitemap(store, options) {
+    if (!options.siteConfig.siteUrl) {
+        return {
+            status: 500,
+            headers: {
+                'content-type': 'text/plain; charset=utf-8',
+            },
+            body: 'sitemap.xml requires siteUrl in mdorigin.config.json',
+        };
+    }
+    const entries = await collectSitemapEntries(store, '', options);
+    const body = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        ...entries.map((entry) => {
+            const lastmod = entry.lastmod ? `<lastmod>${escapeHtml(entry.lastmod)}</lastmod>` : '';
+            return `  <url><loc>${escapeHtml(`${options.siteConfig.siteUrl}${entry.path}`)}</loc>${lastmod}</url>`;
+        }),
+        '</urlset>',
+    ].join('\n');
+    return {
+        status: 200,
+        headers: {
+            'content-type': 'application/xml; charset=utf-8',
+        },
+        body,
+    };
+}
+function withVaryAcceptIfNeeded(headers, enabled) {
+    if (!enabled) {
+        return headers;
+    }
+    return {
+        ...headers,
+        vary: appendVary(headers.vary, 'Accept'),
+    };
+}
+function appendVary(existing, value) {
+    if (!existing || existing.trim() === '') {
+        return value;
+    }
+    const parts = existing.split(',').map((part) => part.trim().toLowerCase());
+    if (parts.includes(value.toLowerCase())) {
+        return existing;
+    }
+    return `${existing}, ${value}`;
+}
 function getDocumentTitle(parsed) {
     if (parsed.meta.title) {
         return parsed.meta.title;
@@ -112,6 +203,50 @@ function getDocumentTitle(parsed) {
         ? path.posix.basename(path.posix.dirname(parsed.sourcePath)) || 'mdorigin'
         : basename;
 }
+async function collectSitemapEntries(store, directoryPath, options) {
+    const entries = await store.listDirectory(directoryPath);
+    if (entries === null) {
+        return [];
+    }
+    const sitemapEntries = [];
+    for (const entry of entries) {
+        if (entry.kind === 'directory') {
+            sitemapEntries.push(...(await collectSitemapEntries(store, entry.path, options)));
+            continue;
+        }
+        if (!isMarkdownEntry(entry)) {
+            continue;
+        }
+        const document = await store.get(entry.path);
+        if (document === null || document.kind !== 'text' || document.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(entry.path, document.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            continue;
+        }
+        sitemapEntries.push({
+            path: getCanonicalHtmlPathForContentPath(entry.path),
+            lastmod: parsed.meta.date,
+        });
+    }
+    sitemapEntries.sort((left, right) => left.path.localeCompare(right.path));
+    return dedupeSitemapEntries(sitemapEntries);
+}
+function dedupeSitemapEntries(entries) {
+    const deduped = new Map();
+    for (const entry of entries) {
+        const existing = deduped.get(entry.path);
+        if (!existing) {
+            deduped.set(entry.path, entry);
+            continue;
+        }
+        if (!existing.lastmod && entry.lastmod) {
+            deduped.set(entry.path, entry);
+        }
+    }
+    return Array.from(deduped.values());
+}
 async function renderDirectoryListing(store, requestPath, siteConfig) {
     const directoryPath = requestPath === '/' ? '' : requestPath.slice(1).replace(/\/$/, '');
     const entries = await store.listDirectory(directoryPath);
@@ -135,6 +270,9 @@ async function renderDirectoryListing(store, requestPath, siteConfig) {
         body: renderDocument({
             siteTitle: siteConfig.siteTitle,
             siteDescription: siteConfig.siteDescription,
+            siteUrl: siteConfig.siteUrl,
+            favicon: siteConfig.favicon,
+            logo: siteConfig.logo,
             title: getDirectoryTitle(requestPath),
             body,
             showSummary: false,
@@ -142,7 +280,12 @@ async function renderDirectoryListing(store, requestPath, siteConfig) {
             theme: siteConfig.theme,
             template: siteConfig.template,
             topNav: navigation.items,
+            footerNav: siteConfig.footerNav,
+            footerText: siteConfig.footerText,
+            socialLinks: siteConfig.socialLinks,
             stylesheetContent: siteConfig.stylesheetContent,
+            canonicalPath: requestPath,
+            alternateMarkdownPath: getMarkdownRequestPathForContentPath(getDirectoryIndexContentPathForRequestPath(requestPath)),
         }),
     };
 }
@@ -167,6 +310,11 @@ function getDirectoryEntryLabel(entry) {
 function getDirectoryTitle(requestPath) {
     return requestPath === '/' ? 'Index' : requestPath;
 }
+function getDirectoryIndexContentPathForRequestPath(requestPath) {
+    return requestPath === '/'
+        ? 'index.md'
+        : `${requestPath.slice(1).replace(/\/$/, '')}/index.md`;
+}
 async function tryRenderAlternateDirectoryIndex(store, requestPath, options) {
     const directoryPath = requestPath === '/' ? '' : requestPath.slice(1).replace(/\/$/, '');
     for (const candidatePath of getDirectoryIndexCandidates(directoryPath)) {
@@ -187,9 +335,15 @@ async function tryRenderAlternateDirectoryIndex(store, requestPath, options) {
             : isRootHomeRequest(requestPath) && navigation.items.length > 0
                 ? stripManagedIndexLinks(entry.text, new Set(navigation.items.map((item) => item.href)))
                 : entry.text;
-        const renderedParsed = renderedBody === entry.text
+        const catalogEntries = options.siteConfig.template === 'catalog'
+            ? extractManagedIndexEntries(renderedBody)
+            : [];
+        const documentBody = options.siteConfig.template === 'catalog'
+            ? stripManagedIndexBlock(renderedBody)
+            : renderedBody;
+        const renderedParsed = documentBody === entry.text
             ? parsed
-            : await parseMarkdownDocument(candidatePath, renderedBody);
+            : await parseMarkdownDocument(candidatePath, documentBody);
         return {
             status: 200,
             headers: {
@@ -198,6 +352,9 @@ async function tryRenderAlternateDirectoryIndex(store, requestPath, options) {
             body: renderDocument({
                 siteTitle: options.siteConfig.siteTitle,
                 siteDescription: options.siteConfig.siteDescription,
+                siteUrl: options.siteConfig.siteUrl,
+                favicon: options.siteConfig.favicon,
+                logo: options.siteConfig.logo,
                 title: getDocumentTitle(parsed),
                 body: renderedParsed.html,
                 summary: options.siteConfig.showSummary === false ? undefined : parsed.meta.summary,
@@ -207,15 +364,170 @@ async function tryRenderAlternateDirectoryIndex(store, requestPath, options) {
                 theme: options.siteConfig.theme,
                 template: options.siteConfig.template,
                 topNav: navigation.items,
+                footerNav: options.siteConfig.footerNav,
+                footerText: options.siteConfig.footerText,
+                socialLinks: options.siteConfig.socialLinks,
+                editLinkHref: getEditLinkHref(options.siteConfig, candidatePath),
                 stylesheetContent: options.siteConfig.stylesheetContent,
+                canonicalPath: requestPath,
+                alternateMarkdownPath: getMarkdownRequestPathForContentPath(candidatePath),
+                catalogEntries,
             }),
         };
     }
     return null;
 }
+async function tryServeAlternateDirectoryMarkdown(store, resolved, options, negotiatedMarkdown) {
+    if (!negotiatedMarkdown || resolved.kind !== 'html' || !resolved.sourcePath) {
+        return null;
+    }
+    if (!resolved.requestPath.endsWith('/')) {
+        return null;
+    }
+    const directoryPath = path.posix.dirname(resolved.sourcePath);
+    for (const candidatePath of getDirectoryIndexCandidates(directoryPath === '.' ? '' : directoryPath)) {
+        if (candidatePath === resolved.sourcePath) {
+            continue;
+        }
+        const entry = await store.get(candidatePath);
+        if (entry === null || entry.kind !== 'text' || entry.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(candidatePath, entry.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            return notFound();
+        }
+        return {
+            status: 200,
+            headers: withVaryAcceptIfNeeded({
+                'content-type': entry.mediaType,
+            }, true),
+            body: entry.text,
+        };
+    }
+    return null;
+}
+async function tryRedirectAlternateDirectoryMarkdown(store, resolved, options) {
+    if (resolved.kind !== 'markdown' || !resolved.sourcePath) {
+        return null;
+    }
+    const basename = path.posix.basename(resolved.sourcePath);
+    if (basename !== 'index.md' && basename !== 'README.md') {
+        return null;
+    }
+    const directoryPath = path.posix.dirname(resolved.sourcePath);
+    for (const candidatePath of getDirectoryIndexCandidates(directoryPath === '.' ? '' : directoryPath)) {
+        if (candidatePath === resolved.sourcePath) {
+            continue;
+        }
+        const entry = await store.get(candidatePath);
+        if (entry === null || entry.kind !== 'text' || entry.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(candidatePath, entry.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            return null;
+        }
+        return redirect(getMarkdownRequestPathForContentPath(candidatePath));
+    }
+    return null;
+}
+function getMarkdownRequestPathForContentPath(contentPath) {
+    return `/${contentPath}`;
+}
 function isRootHomeRequest(requestPath) {
     return requestPath === '/';
 }
+function shouldServeMarkdownForRequest(resolved, acceptHeader) {
+    return shouldVaryOnAccept(resolved) && acceptsMarkdown(acceptHeader);
+}
+function shouldVaryOnAccept(resolved) {
+    if (resolved.kind !== 'html') {
+        return false;
+    }
+    return !resolved.requestPath.endsWith('.html');
+}
+function acceptsMarkdown(acceptHeader) {
+    if (!acceptHeader) {
+        return false;
+    }
+    return acceptHeader
+        .split(',')
+        .map((part) => part.split(';', 1)[0]?.trim().toLowerCase())
+        .includes('text/markdown');
+}
+async function tryRedirectAlias(store, pathname, options) {
+    const normalizedRequestPath = normalizeRequestPath(pathname);
+    if (normalizedRequestPath === null) {
+        return null;
+    }
+    const redirectLocation = await findAliasRedirectLocation(store, '', normalizedRequestPath, options);
+    if (!redirectLocation || redirectLocation === normalizedRequestPath) {
+        return null;
+    }
+    return redirect(redirectLocation);
+}
+async function findAliasRedirectLocation(store, directoryPath, requestPath, options) {
+    const entries = await store.listDirectory(directoryPath);
+    if (entries === null) {
+        return null;
+    }
+    for (const entry of entries) {
+        if (entry.kind === 'directory') {
+            const nestedMatch = await findAliasRedirectLocation(store, entry.path, requestPath, options);
+            if (nestedMatch !== null) {
+                return nestedMatch;
+            }
+            continue;
+        }
+        if (!isMarkdownEntry(entry)) {
+            continue;
+        }
+        const document = await store.get(entry.path);
+        if (document === null || document.kind !== 'text' || document.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(entry.path, document.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            continue;
+        }
+        const aliases = normalizeAliases(parsed.meta.aliases);
+        if (!aliases.includes(requestPath)) {
+            continue;
+        }
+        return getCanonicalHtmlPathForContentPath(entry.path);
+    }
+    return null;
+}
+function isMarkdownEntry(entry) {
+    return path.posix.extname(entry.name).toLowerCase() === '.md';
+}
+function normalizeAliases(aliases) {
+    if (!Array.isArray(aliases)) {
+        return [];
+    }
+    return aliases.flatMap((alias) => {
+        if (typeof alias !== 'string') {
+            return [];
+        }
+        const normalized = normalizeRequestPath(alias);
+        return normalized === null ? [] : [normalized];
+    });
+}
+function getCanonicalHtmlPathForContentPath(contentPath) {
+    const basename = path.posix.basename(contentPath).toLowerCase();
+    if (basename === 'index.md' || basename === 'readme.md') {
+        const directory = path.posix.dirname(contentPath);
+        return directory === '.' ? '/' : `/${directory}/`;
+    }
+    return `/${contentPath.slice(0, -'.md'.length)}`;
+}
+function getEditLinkHref(siteConfig, sourcePath) {
+    if (!siteConfig.editLink || !sourcePath) {
+        return undefined;
+    }
+    return `${siteConfig.editLink.baseUrl}${sourcePath}`;
+}
 async function resolveTopNav(store, siteConfig) {
     if (siteConfig.topNav.length > 0) {
         return {

package/dist/core/router.d.ts

@@ -5,3 +5,4 @@ export interface ResolvedRequest {
     sourcePath?: string;
 }
 export declare function resolveRequest(pathname: string): ResolvedRequest;
+export declare function normalizeRequestPath(pathname: string): string | null;

package/dist/core/router.js

@@ -63,7 +63,7 @@ export function resolveRequest(pathname) {
             sourcePath,
         };
 }
-function normalizeRequestPath(pathname) {
+export function normalizeRequestPath(pathname) {
     try {
         const decoded = decodeURIComponent(pathname || '/');
         const collapsed = decoded.replace(/\/{2,}/g, '/');

package/dist/core/site-config.d.ts

@@ -5,25 +5,52 @@ export interface SiteNavItem {
     label: string;
     href: string;
 }
+export interface SiteLogo {
+    src: string;
+    alt?: string;
+    href?: string;
+}
+export interface SiteSocialLink {
+    icon: string;
+    label: string;
+    href: string;
+}
+export interface EditLinkConfig {
+    baseUrl: string;
+}
 export interface SiteConfig {
     siteTitle?: string;
     siteDescription?: string;
+    siteUrl?: string;
+    favicon?: string;
+    logo?: SiteLogo;
     showDate?: boolean;
     showSummary?: boolean;
     stylesheet?: string;
     theme?: BuiltInThemeName;
     template?: TemplateName;
     topNav?: SiteNavItem[];
+    footerNav?: SiteNavItem[];
+    footerText?: string;
+    socialLinks?: SiteSocialLink[];
+    editLink?: EditLinkConfig;
     showHomeIndex?: boolean;
 }
 export interface ResolvedSiteConfig {
     siteTitle: string;
     siteDescription?: string;
+    siteUrl?: string;
+    favicon?: string;
+    logo?: SiteLogo;
     showDate: boolean;
     showSummary: boolean;
     theme: BuiltInThemeName;
     template: TemplateName;
     topNav: SiteNavItem[];
+    footerNav: SiteNavItem[];
+    footerText?: string;
+    socialLinks: SiteSocialLink[];
+    editLink?: EditLinkConfig;
     showHomeIndex: boolean;
     stylesheetContent?: string;
     siteTitleConfigured: boolean;