svedocs 0.1.0-beta.2

package/dist/core/checks.js

@@ -0,0 +1,252 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { checkLink, createLinkCheckContext } from './links.js';
+import { findDuplicates, normalizePath } from './utils.js';
+export async function checkSvedocsContent(manifest, projectRoot = process.cwd()) {
+    const issues = [];
+    const routeDuplicates = findDuplicates(manifest.pages.map((page) => page.routePath));
+    const canonicalDuplicates = findDuplicates(manifest.pages
+        .map((page) => page.seo.canonical)
+        .filter((canonical) => Boolean(canonical)));
+    if (manifest.config.build.mode === 'spa') {
+        issues.push({
+            code: 'spa-risk',
+            severity: 'warning',
+            message: 'SPA mode prerenders known pages, but server-only routes and provider bindings are unavailable on static hosts.'
+        });
+    }
+    for (const route of routeDuplicates) {
+        issues.push({
+            code: 'duplicate-route',
+            severity: 'error',
+            message: `Duplicate route path detected: ${route}`
+        });
+    }
+    for (const canonical of canonicalDuplicates) {
+        issues.push({
+            code: 'duplicate-canonical',
+            severity: 'error',
+            message: `Duplicate canonical URL detected: ${canonical}`
+        });
+    }
+    if (manifest.config.checks.translations) {
+        issues.push(...createMissingTranslationIssues(manifest));
+    }
+    const linkContext = createLinkCheckContext(manifest);
+    for (const page of manifest.pages) {
+        if (!page.description) {
+            issues.push({
+                code: 'missing-description',
+                severity: 'warning',
+                message: `${page.routePath} is missing a description for SEO and search excerpts.`,
+                pageId: page.id,
+                sourcePath: page.sourcePath
+            });
+        }
+        if (page.plainText && page.search.length === 0) {
+            issues.push({
+                code: 'empty-search',
+                severity: 'warning',
+                message: `${page.routePath} has content but produced no search records.`,
+                pageId: page.id,
+                sourcePath: page.sourcePath
+            });
+        }
+        for (const link of page.links) {
+            const issue = checkLink(page, link, linkContext)
+                ?? await checkAssetLink(projectRoot, page.sourcePath, link, manifest.config.checks.assets)
+                ?? await checkExternalLink(link, manifest.config.checks.externalLinks, page.id, page.sourcePath);
+            if (issue)
+                issues.push(issue);
+        }
+    }
+    return issues;
+}
+function createMissingTranslationIssues(manifest) {
+    const locales = manifest.config.i18n.locales.map((locale) => locale.code);
+    if (locales.length <= 1)
+        return [];
+    const groups = new Map();
+    for (const page of manifest.pages) {
+        if (page.hidden || page.kind !== 'doc')
+            continue;
+        const key = page.scopePath;
+        const group = groups.get(key) ?? [];
+        group.push(page);
+        groups.set(key, group);
+    }
+    const issues = [];
+    for (const pages of groups.values()) {
+        const present = new Set(pages.map((page) => page.locale).filter((locale) => Boolean(locale)));
+        const reference = pages[0];
+        if (!reference)
+            continue;
+        for (const locale of locales) {
+            if (present.has(locale))
+                continue;
+            issues.push({
+                code: 'missing-translation',
+                severity: 'warning',
+                message: `${reference.scopePath} is missing locale ${locale}.`,
+                pageId: reference.id,
+                sourcePath: reference.sourcePath
+            });
+        }
+    }
+    return issues;
+}
+export async function checkPackagePublication(packageRoot) {
+    const issues = [];
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+    const pkg = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+    if (!pkg.private && pkg.license !== 'MIT') {
+        issues.push({
+            code: 'package-license-missing',
+            severity: 'error',
+            message: 'package.json license must be MIT for public svedocs packages.'
+        });
+    }
+    if (!pkg.private && pkg.publishConfig?.access !== 'public') {
+        issues.push({
+            code: 'package-publish-access-missing',
+            severity: 'warning',
+            message: 'package.json publishConfig.access should be public before publishing.'
+        });
+    }
+    if (!pkg.private && pkg.publishConfig?.provenance !== true) {
+        issues.push({
+            code: 'package-provenance-missing',
+            severity: 'warning',
+            message: 'package.json publishConfig.provenance should be true for npm provenance.'
+        });
+    }
+    for (const target of extractBinTargets(pkg.bin)) {
+        if (!await fileExists(path.join(packageRoot, target))) {
+            issues.push({
+                code: 'package-bin-missing',
+                severity: 'error',
+                message: `package.json bin target is missing: ${target}.`
+            });
+        }
+    }
+    for (const [exportName, value] of Object.entries(pkg.exports ?? {})) {
+        const targets = extractExportTargets(value);
+        for (const target of targets) {
+            if (!await fileExists(path.join(packageRoot, target))) {
+                issues.push({
+                    code: 'package-export-missing',
+                    severity: 'error',
+                    message: `${exportName} points to missing package export target ${target}.`
+                });
+            }
+        }
+    }
+    for (const file of pkg.files ?? []) {
+        if (!await fileExists(path.join(packageRoot, file))) {
+            issues.push({
+                code: 'package-file-missing',
+                severity: 'error',
+                message: `package.json files entry is missing: ${file}.`
+            });
+        }
+    }
+    return issues;
+}
+function extractBinTargets(bin) {
+    if (!bin)
+        return [];
+    if (typeof bin === 'string')
+        return [normalizePackageTarget(bin)];
+    return Object.values(bin).map(normalizePackageTarget);
+}
+async function checkAssetLink(projectRoot, sourcePath, link, enabled) {
+    if (!enabled || link.kind !== 'asset')
+        return undefined;
+    const pathname = splitHrefPath(link.href);
+    const candidates = pathname.startsWith('/')
+        ? [
+            path.join(projectRoot, 'static', pathname),
+            path.join(projectRoot, pathname)
+        ]
+        : [
+            path.join(projectRoot, path.posix.dirname(normalizePath(sourcePath)), pathname),
+            path.join(projectRoot, 'static', pathname)
+        ];
+    if (await anyFileExists(candidates))
+        return undefined;
+    return {
+        code: 'broken-asset',
+        severity: 'error',
+        message: `${sourcePath}:${link.line} references missing asset ${link.href}.`,
+        pageId: sourcePath,
+        sourcePath,
+        href: link.href
+    };
+}
+async function checkExternalLink(link, enabled, pageId, sourcePath) {
+    if (!enabled || link.kind !== 'external' || !/^https?:\/\//.test(link.href))
+        return undefined;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 4_000);
+    try {
+        const response = await fetch(link.href, {
+            method: 'HEAD',
+            redirect: 'follow',
+            signal: controller.signal
+        });
+        if (response.ok || response.status === 405)
+            return undefined;
+        return {
+            code: 'external-link-unchecked',
+            severity: 'warning',
+            message: `${sourcePath}:${link.line} external link returned ${response.status}: ${link.href}.`,
+            pageId,
+            sourcePath,
+            href: link.href
+        };
+    }
+    catch {
+        return {
+            code: 'external-link-unchecked',
+            severity: 'warning',
+            message: `${sourcePath}:${link.line} external link could not be verified: ${link.href}.`,
+            pageId,
+            sourcePath,
+            href: link.href
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function extractExportTargets(value) {
+    if (typeof value === 'string')
+        return [normalizePackageTarget(value)];
+    if (!value || typeof value !== 'object')
+        return [];
+    return Object.values(value).flatMap(extractExportTargets);
+}
+function normalizePackageTarget(target) {
+    return target.replace(/^\.\//, '');
+}
+function splitHrefPath(href) {
+    const [withoutHash = ''] = href.trim().split('#');
+    const [pathname = ''] = withoutHash.split('?');
+    return pathname;
+}
+async function anyFileExists(paths) {
+    for (const candidate of paths) {
+        if (await fileExists(candidate))
+            return true;
+    }
+    return false;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,5 @@
+import type { SvedocsConfig } from '../config.js';
+import type { SvedocsResolvedConfig } from './types.js';
+export declare function resolveSvedocsConfig(config?: SvedocsConfig): SvedocsResolvedConfig;
+export declare function isResolvedConfig(config: SvedocsConfig | SvedocsResolvedConfig | undefined): config is SvedocsResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAiB,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEvE,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,aAAkB,GAAG,qBAAqB,CAmItF;AAeD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,qBAAqB,GAAG,SAAS,GAAG,MAAM,IAAI,qBAAqB,CAY3H"}

package/dist/core/config.js

@@ -0,0 +1,182 @@
+export function resolveSvedocsConfig(config = {}) {
+    const contentRoot = config.content?.root ?? 'content';
+    const docsRoot = config.content?.docs ?? `${contentRoot}/docs`;
+    const pagesRoot = config.content?.pages ?? `${contentRoot}/pages`;
+    const search = config.search === false ? { enabled: false, provider: 'local', scope: 'current' } : {
+        enabled: config.search?.enabled ?? true,
+        provider: config.search?.provider ?? 'local',
+        scope: config.search?.scope ?? 'current'
+    };
+    const ai = config.ai === false ? {
+        enabled: false,
+        provider: 'mock',
+        scope: 'current',
+        label: 'Ask AI',
+        placeholder: 'Ask about the docs',
+        suggestions: [],
+        maxResults: 5
+    } : {
+        enabled: config.ai?.enabled ?? Boolean(config.ai?.provider),
+        provider: config.ai?.provider ?? 'mock',
+        scope: config.ai?.scope ?? 'current',
+        label: config.ai?.label ?? 'Ask AI',
+        placeholder: config.ai?.placeholder ?? 'Ask about the docs',
+        suggestions: config.ai?.suggestions ?? [],
+        maxResults: config.ai?.maxResults ?? 5,
+        ...(config.ai?.systemPrompt ? { systemPrompt: config.ai.systemPrompt } : {}),
+        ...(config.ai?.welcomeMessage ? { welcomeMessage: config.ai.welcomeMessage } : {})
+    };
+    return {
+        site: {
+            name: config.site?.name ?? 'svedocs',
+            title: config.site?.title ?? config.site?.name ?? 'svedocs',
+            description: config.site?.description ?? 'SvelteKit-native documentation framework.',
+            ...(config.site?.url ? { url: config.site.url } : {})
+        },
+        content: {
+            root: contentRoot,
+            docs: docsRoot,
+            pages: pagesRoot,
+            include: config.content?.include ?? [`${contentRoot}/**/*.{md,mdx,svx}`],
+            exclude: config.content?.exclude ?? [
+                '**/_*.{md,mdx,svx}',
+                '**/node_modules/**',
+                '**/dist/**',
+                '**/build/**',
+                '**/.svelte-kit/**'
+            ]
+        },
+        build: {
+            mode: config.build?.mode ?? 'edge'
+        },
+        theme: {
+            defaultMode: config.theme?.defaultMode ?? 'system',
+            palette: {
+                accent: config.theme?.palette?.accent ?? 'emerald',
+                neutral: config.theme?.palette?.neutral ?? 'zinc'
+            },
+            fonts: {
+                sans: config.theme?.fonts?.sans ?? '"IBM Plex Sans", "Avenir Next", sans-serif',
+                mono: config.theme?.fonts?.mono ?? '"JetBrains Mono", "SFMono-Regular", monospace',
+                display: config.theme?.fonts?.display ?? '"IBM Plex Sans", "Avenir Next", sans-serif'
+            },
+            radius: config.theme?.radius ?? '0px',
+            codeTheme: resolveCodeTheme(config.theme?.codeTheme),
+            code: {
+                lineNumbers: config.theme?.code?.lineNumbers ?? true,
+                wrap: config.theme?.code?.wrap ?? false
+            },
+            brand: {
+                label: config.theme?.brand?.label ?? config.site?.name ?? 'svedocs',
+                href: config.theme?.brand?.href ?? '/',
+                ...(config.theme?.brand?.logo ? { logo: config.theme.brand.logo } : {}),
+                mark: config.theme?.brand?.mark ?? 'pixel'
+            },
+            nav: config.theme?.nav ?? [
+                { label: 'Docs', href: '/docs' }
+            ],
+            social: config.theme?.social ?? [],
+            footer: config.theme?.footer === false
+                ? false
+                : {
+                    text: config.theme?.footer?.text ?? `MIT licensed. Built with ${config.site?.name ?? 'svedocs'}.`,
+                    links: config.theme?.footer?.links ?? []
+                },
+            home: {
+                kicker: config.theme?.home?.kicker ?? 'SvelteKit-native docs',
+                ...(config.theme?.home?.primaryAction ? { primaryAction: config.theme.home.primaryAction } : {}),
+                ...(config.theme?.home?.secondaryAction ? { secondaryAction: config.theme.home.secondaryAction } : {}),
+                visual: {
+                    type: config.theme?.home?.visual?.type ?? 'pixel',
+                    ...(config.theme?.home?.visual?.src ? { src: config.theme.home.visual.src } : {}),
+                    alt: config.theme?.home?.visual?.alt ?? ''
+                }
+            }
+        },
+        search,
+        ai,
+        seo: {
+            sitemap: config.seo?.sitemap ?? true,
+            robots: config.seo?.robots ?? true,
+            ...(config.seo?.defaultAuthor ? { defaultAuthor: config.seo.defaultAuthor } : {}),
+            ogImage: config.seo?.ogImage === false
+                ? false
+                : {
+                    template: config.seo?.ogImage?.template ?? 'default',
+                    format: config.seo?.ogImage?.format ?? 'svg',
+                    outDir: config.seo?.ogImage?.outDir ?? 'static/og',
+                    renderer: config.seo?.ogImage?.renderer ?? 'svg'
+                }
+        },
+        source: {
+            ...(config.source?.editBaseUrl ? { editBaseUrl: config.source.editBaseUrl } : {})
+        },
+        cloudflare: {
+            compatibilityDate: config.cloudflare?.compatibilityDate ?? '2026-05-18',
+            aiSearch: {
+                binding: config.cloudflare?.aiSearch?.binding ?? 'SVEDOCS_AI_SEARCH',
+                instanceName: config.cloudflare?.aiSearch?.instanceName ?? 'svedocs',
+                ...(config.cloudflare?.aiSearch?.namespace ? { namespace: config.cloudflare.aiSearch.namespace } : {}),
+                remote: config.cloudflare?.aiSearch?.remote ?? false
+            }
+        },
+        checks: {
+            assets: config.checks?.assets ?? true,
+            externalLinks: config.checks?.externalLinks ?? false,
+            translations: config.checks?.translations ?? false,
+        },
+        i18n: resolveI18nConfig(config)
+    };
+}
+function resolveCodeTheme(input) {
+    if (typeof input === 'string') {
+        return {
+            light: input,
+            dark: input
+        };
+    }
+    return {
+        light: input?.light ?? 'github-light',
+        dark: input?.dark ?? 'github-dark'
+    };
+}
+export function isResolvedConfig(config) {
+    const candidate = config;
+    return Boolean(candidate
+        && Array.isArray(candidate.content?.include)
+        && Array.isArray(candidate.content?.exclude)
+        && typeof candidate.search?.enabled === 'boolean'
+        && typeof candidate.ai?.enabled === 'boolean'
+        && typeof candidate.theme?.fonts?.sans === 'string'
+        && typeof candidate.theme?.brand?.label === 'string'
+        && typeof candidate.cloudflare?.compatibilityDate === 'string');
+}
+function resolveI18nConfig(config) {
+    if (config.i18n === false) {
+        return {
+            locales: [],
+            prefixDefaultLocale: false
+        };
+    }
+    const locales = (config.i18n?.locales ?? []).map(normalizeLocale);
+    const defaultLocale = config.i18n?.defaultLocale ?? locales[0]?.code;
+    return {
+        ...(defaultLocale ? { defaultLocale } : {}),
+        locales,
+        prefixDefaultLocale: config.i18n?.prefixDefaultLocale ?? false
+    };
+}
+function normalizeLocale(locale) {
+    if (typeof locale === 'string') {
+        return {
+            code: locale,
+            label: locale,
+            path: locale
+        };
+    }
+    return {
+        code: locale.code,
+        label: locale.label ?? locale.code,
+        path: locale.path ?? locale.code
+    };
+}

package/dist/core/content.d.ts

@@ -0,0 +1,7 @@
+import type { SvedocsConfig } from '../config.js';
+import type { SvedocsContentManifest, SvedocsResolvedConfig } from './types.js';
+export declare function loadSvedocsContent(options?: {
+    projectRoot?: string;
+    config?: SvedocsConfig | SvedocsResolvedConfig;
+}): Promise<SvedocsContentManifest>;
+//# sourceMappingURL=content.d.ts.map

package/dist/core/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/core/content.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAOlD,OAAO,KAAK,EAAE,sBAAsB,EAAe,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAW7F,wBAAsB,kBAAkB,CAAC,OAAO,GAAE;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,aAAa,GAAG,qBAAqB,CAAC;CAC3C,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA+BvC"}

package/dist/core/content.js

@@ -0,0 +1,211 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import fg from 'fast-glob';
+import matter from 'gray-matter';
+import { compileMarkdown } from '../mdx/compile.js';
+import { checkSvedocsContent } from './checks.js';
+import { isResolvedConfig, resolveSvedocsConfig } from './config.js';
+import { extractMarkdownLinks } from './links.js';
+import { createPageTree, wirePrevNext } from './navigation.js';
+import { createPageSearchRecords, createSearchRecords } from './search.js';
+import { booleanFrontmatter, normalizePath, numberFrontmatter, stringArrayFrontmatter, stringFrontmatter, stripInlineMarkdown, titleFromSegment } from './utils.js';
+export async function loadSvedocsContent(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const rawConfig = isResolvedConfig(options.config) ? undefined : options.config;
+    const config = isResolvedConfig(options.config)
+        ? options.config
+        : resolveSvedocsConfig(options.config ?? {});
+    const markdownOptions = createMarkdownCompileOptions(rawConfig, config);
+    const files = await fg(config.content.include, {
+        cwd: projectRoot,
+        absolute: false,
+        ignore: config.content.exclude,
+        onlyFiles: true
+    });
+    const pages = await Promise.all(files
+        .filter((file) => isContentFile(file))
+        .sort()
+        .map((file) => loadContentFile(projectRoot, file, config, markdownOptions)));
+    const sorted = pages.sort((a, b) => a.routePath.localeCompare(b.routePath));
+    const tree = createPageTree(sorted);
+    wirePrevNext(sorted, tree);
+    const manifest = {
+        config,
+        pages: sorted,
+        tree,
+        search: createSearchRecords(sorted),
+        issues: []
+    };
+    manifest.issues = await checkSvedocsContent(manifest, projectRoot);
+    return manifest;
+}
+function isContentFile(file) {
+    return /\.(md|mdx|svx)$/.test(file);
+}
+async function loadContentFile(projectRoot, file, config, markdownOptions) {
+    const sourcePath = path.join(projectRoot, file);
+    const raw = await readFile(sourcePath, 'utf8');
+    const fileStats = await stat(sourcePath);
+    const parsed = matter(raw);
+    const markdown = parsed.content.trim();
+    const frontmatter = parsed.data;
+    const discoveredTitle = extractFirstMarkdownTitle(markdown);
+    const titleFromFrontmatter = stringFrontmatter(frontmatter.title);
+    const renderMarkdown = stripLeadingTitleHeading(markdown, titleFromFrontmatter ?? discoveredTitle);
+    const compiled = await compileMarkdown(renderMarkdown, markdownOptions);
+    const kind = inferKind(file, config);
+    const route = createRouteInfo(file, kind, config);
+    const routePath = route.routePath;
+    const title = titleFromFrontmatter ?? discoveredTitle ?? compiled.title ?? titleFromRoute(routePath);
+    const navTitle = stringFrontmatter(frontmatter.navTitle) ?? stringFrontmatter(frontmatter.nav_title);
+    const description = stringFrontmatter(frontmatter.description);
+    const order = numberFrontmatter(frontmatter.order);
+    const hidden = booleanFrontmatter(frontmatter.hidden);
+    const collapsed = booleanFrontmatter(frontmatter.collapsed);
+    const section = booleanFrontmatter(frontmatter.section);
+    const icon = stringFrontmatter(frontmatter.icon);
+    const keywords = stringArrayFrontmatter(frontmatter.keywords);
+    const type = stringFrontmatter(frontmatter.type) ?? stringFrontmatter(frontmatter.ogType) ?? stringFrontmatter(frontmatter.og_type);
+    const author = stringFrontmatter(frontmatter.author) ?? config.seo.defaultAuthor;
+    const publishedTime = dateFrontmatter(frontmatter.publishedTime)
+        ?? dateFrontmatter(frontmatter.published_time)
+        ?? dateFrontmatter(frontmatter.published)
+        ?? dateFrontmatter(frontmatter.date);
+    const updatedTime = dateFrontmatter(frontmatter.updatedTime)
+        ?? dateFrontmatter(frontmatter.updated_time)
+        ?? dateFrontmatter(frontmatter.updated);
+    const canonical = stringFrontmatter(frontmatter.canonical) ?? (config.site.url ? new URL(routePath, config.site.url).href : undefined);
+    const image = stringFrontmatter(frontmatter.image);
+    const page = {
+        id: createPageId(file),
+        sourcePath: file,
+        routePath,
+        scopePath: route.scopePath,
+        slug: route.slug,
+        ...(route.locale ? { locale: route.locale } : {}),
+        kind,
+        title,
+        ...(navTitle ? { navTitle } : {}),
+        ...(description ? { description } : {}),
+        ...(typeof order === 'number' ? { order } : {}),
+        ...(hidden === true ? { hidden } : {}),
+        ...(typeof collapsed === 'boolean' ? { collapsed } : {}),
+        ...(section === true ? { section } : {}),
+        ...(icon ? { icon } : {}),
+        html: compiled.html,
+        plainText: compiled.plainText,
+        headings: compiled.headings,
+        links: extractMarkdownLinks(markdown),
+        codeBlocks: compiled.codeBlocks,
+        frontmatter,
+        seo: {
+            title,
+            ...(description ? { description } : {}),
+            ...(canonical ? { canonical } : {}),
+            ...(image ? { image } : {}),
+            ...(keywords.length > 0 ? { keywords } : {}),
+            ...(type ? { type } : {}),
+            ...(author ? { author } : {}),
+            ...(publishedTime ? { publishedTime } : {}),
+            ...(updatedTime ? { updatedTime } : {})
+        },
+        search: [],
+        lastUpdated: fileStats.mtime.toISOString(),
+        ...(config.source.editBaseUrl ? { editUrl: createEditUrl(config.source.editBaseUrl, file) } : {})
+    };
+    page.search = createPageSearchRecords(page, renderMarkdown);
+    return page;
+}
+function createMarkdownCompileOptions(rawConfig, resolvedConfig) {
+    return {
+        ...(rawConfig?.markdown?.remarkPlugins ? { remarkPlugins: rawConfig.markdown.remarkPlugins } : {}),
+        ...(rawConfig?.markdown?.rehypePlugins ? { rehypePlugins: rawConfig.markdown.rehypePlugins } : {}),
+        ...(rawConfig?.markdown?.shiki?.transformers ? { shikiTransformers: rawConfig.markdown.shiki.transformers } : {}),
+        codeThemes: {
+            light: resolvedConfig.theme.codeTheme.light,
+            dark: resolvedConfig.theme.codeTheme.dark
+        },
+        codeLineNumbers: resolvedConfig.theme.code.lineNumbers,
+        codeWrap: resolvedConfig.theme.code.wrap
+    };
+}
+function createEditUrl(baseUrl, sourcePath) {
+    return `${baseUrl.replace(/\/$/, '')}/${normalizePath(sourcePath)}`;
+}
+function dateFrontmatter(value) {
+    const text = stringFrontmatter(value);
+    if (text)
+        return text;
+    if (value instanceof Date && !Number.isNaN(value.valueOf()))
+        return value.toISOString();
+    return undefined;
+}
+function inferKind(file, config) {
+    return normalizePath(file).startsWith(`${normalizePath(config.content.docs)}/`) ? 'doc' : 'page';
+}
+function createRouteInfo(file, kind, config) {
+    const normalized = normalizePath(file);
+    const base = normalizePath(kind === 'doc' ? config.content.docs : config.content.pages);
+    const relative = normalized.startsWith(`${base}/`) ? normalized.slice(base.length + 1) : normalized;
+    const withoutExt = relative.replace(/\.(md|mdx|svx)$/, '');
+    const rawParts = withoutExt.split('/').filter(Boolean);
+    const parts = rawParts.at(-1) === 'index' ? rawParts.slice(0, -1) : [...rawParts];
+    const routeParts = kind === 'doc' ? ['docs'] : [];
+    const locale = consumeLocale(parts, config);
+    const scopeParts = [...parts];
+    if (locale && shouldPrefixLocale(locale, config)) {
+        routeParts.push(findLocalePath(locale, config) ?? locale);
+    }
+    routeParts.push(...parts);
+    const routePath = `/${routeParts.join('/')}`.replace(/\/$/, '') || '/';
+    const scopePath = `/${[...(kind === 'doc' ? ['docs'] : []), ...scopeParts].join('/')}`.replace(/\/$/, '') || '/';
+    return {
+        routePath,
+        scopePath,
+        slug: routePath.split('/').filter(Boolean),
+        ...(locale ? { locale } : {})
+    };
+}
+function consumeLocale(parts, config) {
+    if (config.i18n.locales.length === 0)
+        return undefined;
+    const match = config.i18n.locales.find((locale) => locale.path === parts[0] || locale.code === parts[0]);
+    if (match) {
+        parts.shift();
+        return match.code;
+    }
+    return config.i18n.defaultLocale;
+}
+function shouldPrefixLocale(locale, config) {
+    return config.i18n.prefixDefaultLocale || locale !== config.i18n.defaultLocale;
+}
+function findLocalePath(locale, config) {
+    return config.i18n.locales.find((item) => item.code === locale)?.path;
+}
+function createPageId(file) {
+    return normalizePath(file).replace(/\.(md|mdx|svx)$/, '').replace(/[^a-zA-Z0-9]+/g, '-');
+}
+function titleFromRoute(routePath) {
+    const last = routePath.split('/').filter(Boolean).at(-1) ?? 'home';
+    return titleFromSegment(last);
+}
+function extractFirstMarkdownTitle(markdown) {
+    const match = /^#\s+(.+?)\s*#*$/m.exec(markdown);
+    return match?.[1] ? stripInlineMarkdown(match[1]) : undefined;
+}
+function stripLeadingTitleHeading(markdown, title) {
+    if (!title)
+        return markdown;
+    const lines = markdown.split(/\r?\n/);
+    const firstContentIndex = lines.findIndex((line) => line.trim().length > 0);
+    if (firstContentIndex < 0)
+        return markdown;
+    const match = /^#\s+(.+?)\s*#*$/.exec(lines[firstContentIndex] ?? '');
+    if (!match?.[1])
+        return markdown;
+    const heading = stripInlineMarkdown(match[1]);
+    if (heading !== title)
+        return markdown;
+    lines.splice(firstContentIndex, 1);
+    return lines.join('\n').trim();
+}

package/dist/core/links.d.ts

@@ -0,0 +1,8 @@
+import type { SvedocsContentIssue, SvedocsContentManifest, SvedocsLinkReference, SvedocsPage } from './types.js';
+export declare function extractMarkdownLinks(markdown: string): SvedocsLinkReference[];
+export declare function createLinkCheckContext(manifest: SvedocsContentManifest): {
+    routeMap: Map<string, SvedocsPage>;
+    sourceMap: Map<string, SvedocsPage>;
+};
+export declare function checkLink(page: SvedocsPage, link: SvedocsLinkReference, context: ReturnType<typeof createLinkCheckContext>): SvedocsContentIssue | undefined;
+//# sourceMappingURL=links.d.ts.map

package/dist/core/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/core/links.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIjH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAE7E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,sBAAsB;;;EAStE;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,GACjD,mBAAmB,GAAG,SAAS,CAwBjC"}