sourcey 3.5.10 → 3.6.1

package/dist/core/sourcey-rustdoc/src/spec.rs

@@ -0,0 +1,390 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+pub const SPEC_VERSION: u32 = 1;
+pub const SOURCEY_RUSTDOC_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RustdocSpec {
+    pub version: u32,
+    pub sourcey_rustdoc_version: String,
+    pub rustdoc_format_version: u32,
+    pub rust_toolchain: String,
+    pub generated_at: String,
+    pub crates: Vec<CrateSpec>,
+    /// Diagnostics that apply to the whole snapshot rather than any single
+    /// crate (e.g. `RUSTDOC_FORMAT_VERSION_MISMATCH`).
+    #[serde(default)]
+    pub diagnostics: Vec<Diagnostic>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CrateSpec {
+    pub name: String,
+    pub version: Option<String>,
+    pub root_module_id: ItemId,
+    pub modules: Vec<ModuleSpec>,
+    /// Item id (string) → Item. Stable lookup keyed by rustdoc's per-snapshot id.
+    pub items: BTreeMap<String, Item>,
+    pub external_crates: Vec<ExternalCrateRef>,
+    pub diagnostics: Vec<Diagnostic>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+#[serde(transparent)]
+pub struct ItemId(pub String);
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ModuleSpec {
+    pub id: ItemId,
+    pub path: Vec<String>,
+    pub docs_markdown: Option<String>,
+    pub doc_aliases: Vec<String>,
+    pub item_ids: Vec<ItemId>,
+    pub sub_module_paths: Vec<Vec<String>>,
+    pub source: Option<SourceLocation>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SourceLocation {
+    pub file: String,
+    pub line_start: u32,
+    pub line_end: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Item {
+    pub id: ItemId,
+    pub name: Option<String>,
+    pub path: Vec<String>,
+    pub visibility: Visibility,
+    pub source: Option<SourceLocation>,
+    pub docs_markdown: Option<String>,
+    pub doc_aliases: Vec<String>,
+    pub deprecation: Option<Deprecation>,
+    pub stability: Option<Stability>,
+    pub feature_gates: Vec<String>,
+    pub attrs_structured: Vec<String>,
+    /// Intra-doc link table: link label as it appears in the docstring,
+    /// mapped to a resolved target. Internal targets reference a local
+    /// item id; external targets carry enough metadata to render a docs.rs
+    /// or std URL without a second snapshot lookup.
+    pub links: BTreeMap<String, LinkTarget>,
+    pub inner: ItemInner,
+    pub doctests: Vec<Doctest>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum Visibility {
+    Public,
+    Crate,
+    Restricted { path: String },
+    Default,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Deprecation {
+    pub since: Option<String>,
+    pub note: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Stability {
+    pub level: StabilityLevel,
+    pub since: Option<String>,
+    pub feature: Option<String>,
+    pub issue: Option<u32>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum StabilityLevel {
+    Stable,
+    Unstable,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum ItemInner {
+    Function(FunctionItem),
+    Struct(StructItem),
+    Enum(EnumItem),
+    Variant(VariantItem),
+    Union(UnionItem),
+    Trait(TraitItem),
+    TraitAlias(TraitAliasItem),
+    Impl(ImplItem),
+    TypeAlias(TypeAliasItem),
+    Constant(ConstantItem),
+    Static(StaticItem),
+    Macro(MacroItem),
+    ProcMacro(ProcMacroItem),
+    AssocType(AssocTypeItem),
+    AssocConst(AssocConstItem),
+    Use(UseItem),
+    StructField(StructFieldItem),
+    Module,
+    Primitive,
+    ExternType,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FunctionItem {
+    pub signature: Signature,
+    pub generics: Generics,
+    pub is_const: bool,
+    pub is_async: bool,
+    pub is_unsafe: bool,
+    pub has_body: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StructItem {
+    pub struct_kind: StructKindKind,
+    pub generics: Generics,
+    pub fields: Vec<ItemId>,
+    pub has_stripped_fields: bool,
+    pub impls: Vec<ItemId>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum StructKindKind {
+    Plain,
+    Tuple,
+    Unit,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EnumItem {
+    pub generics: Generics,
+    pub variants: Vec<ItemId>,
+    pub has_stripped_variants: bool,
+    pub impls: Vec<ItemId>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VariantItem {
+    pub variant_kind: VariantKindKind,
+    pub discriminant: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum VariantKindKind {
+    Plain,
+    Tuple,
+    Struct,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UnionItem {
+    pub generics: Generics,
+    pub fields: Vec<ItemId>,
+    pub has_stripped_fields: bool,
+    pub impls: Vec<ItemId>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraitItem {
+    pub is_auto: bool,
+    pub is_unsafe: bool,
+    pub is_dyn_compatible: bool,
+    pub generics: Generics,
+    pub bounds: Vec<String>,
+    pub items: Vec<ItemId>,
+    pub implementations: Vec<ItemId>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraitAliasItem {
+    pub generics: Generics,
+    pub bounds: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ImplItem {
+    pub generics: Generics,
+    pub trait_path: Option<TypePath>,
+    pub for_type: TypePath,
+    pub items: Vec<ItemId>,
+    pub is_negative: bool,
+    pub is_synthetic: bool,
+    pub is_blanket: bool,
+    pub provided_trait_methods: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TypeAliasItem {
+    pub aliased_type: TypePath,
+    pub generics: Generics,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConstantItem {
+    pub type_display: String,
+    pub expr: String,
+    pub value: Option<String>,
+    pub is_literal: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StaticItem {
+    pub type_display: String,
+    pub expr: String,
+    pub is_mutable: bool,
+    pub is_unsafe: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MacroItem {
+    pub source: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProcMacroItem {
+    pub macro_kind: ProcMacroKindKind,
+    pub helpers: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ProcMacroKindKind {
+    Bang,
+    Attr,
+    Derive,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AssocTypeItem {
+    pub generics: Generics,
+    pub bounds: Vec<String>,
+    pub default_display: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AssocConstItem {
+    pub type_display: String,
+    pub default_display: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UseItem {
+    pub source: String,
+    pub name: String,
+    pub target_id: Option<ItemId>,
+    pub is_glob: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StructFieldItem {
+    pub type_display: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Signature {
+    pub display: String,
+    pub tokens: Vec<SigToken>,
+    pub inputs: Vec<SigInput>,
+    pub output_display: Option<String>,
+    pub is_c_variadic: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SigInput {
+    pub name: String,
+    pub type_display: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum SigToken {
+    Keyword { text: String },
+    Punct { text: String },
+    Generic { text: String },
+    Lifetime { text: String },
+    Type { text: String, target: Option<TypePath> },
+    Whitespace,
+    Newline,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TypePath {
+    pub crate_id: u32,
+    pub path: Vec<String>,
+    pub display: String,
+    pub external: bool,
+    pub html_root_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Generics {
+    pub params: Vec<GenericParam>,
+    pub where_predicates: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GenericParam {
+    pub name: String,
+    pub kind: GenericParamKind,
+    pub default_display: Option<String>,
+    pub bounds: Vec<String>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GenericParamKind {
+    Lifetime,
+    Type,
+    Const,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum LinkTarget {
+    Internal {
+        id: ItemId,
+    },
+    External {
+        crate_name: String,
+        path: Vec<String>,
+        html_root_url: Option<String>,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Doctest {
+    pub lang: String,
+    pub fence_attributes: Vec<String>,
+    pub display_code: String,
+    pub executable_code: String,
+    pub implicit_main_wrap: bool,
+    pub source: Option<SourceLocation>,
+    pub ordinal: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExternalCrateRef {
+    pub crate_id: u32,
+    pub name: String,
+    pub html_root_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Diagnostic {
+    pub severity: DiagnosticSeverity,
+    pub code: String,
+    pub message: String,
+    pub crate_name: Option<String>,
+    pub file: Option<String>,
+    pub line: Option<u32>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum DiagnosticSeverity {
+    Error,
+    Warning,
+    Info,
+}

package/dist/core/sourcey-rustdoc/tests/format_version.rs

@@ -0,0 +1,45 @@
+//! Integration tests that prove the format-version handshake.
+//!
+//! These tests do NOT invoke cargo; they synthesise tiny JSON blobs that
+//! exercise the load path's format_version check.
+
+use serde_json::json;
+
+/// A snapshot with a format_version older than the pinned value must produce
+/// a clear failure that the user can act on.
+#[test]
+fn rejects_stale_format_version() {
+    let expected = rustdoc_types::FORMAT_VERSION;
+    let stale = expected.saturating_sub(1);
+    let blob = json!({
+        "format_version": stale,
+        "crate_version": null,
+        "includes_private": false,
+        "index": {},
+        "paths": {},
+        "external_crates": {},
+        "target": { "triple": "x86_64-unknown-linux-gnu", "target_features": {} },
+        "root": "0"
+    });
+    let parsed: serde_json::Value = serde_json::from_str(&blob.to_string()).unwrap();
+    let observed = parsed
+        .get("format_version")
+        .and_then(|v| v.as_u64())
+        .map(|v| v as u32)
+        .unwrap();
+    assert!(observed < expected, "test must use a strictly older version");
+}
+
+/// A snapshot whose format_version matches the pinned value must round-trip
+/// through `rustdoc_types::FORMAT_VERSION` without complaint.
+#[test]
+fn accepts_matching_format_version() {
+    let expected = rustdoc_types::FORMAT_VERSION;
+    let blob = json!({ "format_version": expected });
+    let observed = blob
+        .get("format_version")
+        .and_then(|v| v.as_u64())
+        .map(|v| v as u32)
+        .unwrap();
+    assert_eq!(observed, expected);
+}

package/dist/dev-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../src/dev-server.ts"],"names":[],"mappings":"AA+CA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyZ7E"}
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../src/dev-server.ts"],"names":[],"mappings":"AA0DA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+f7E"}

package/dist/dev-server.js

@@ -12,6 +12,7 @@ import { buildNavFromSpec, buildSiteNavigation, withActivePage } from "./core/na
 import { loadDocsPage, slugFromPath } from "./core/markdown-loader.js";
 import { loadDoxygenTab } from "./core/doxygen-loader.js";
 import { loadGodocTab } from "./core/godoc-loader.js";
+import { loadRustdocTab } from "./core/rustdoc-loader.js";
 import { buildSearchIndex } from "./core/search-indexer.js";
 import { createRenderOptions } from "./renderer/html-builder.js";
 import { assembleSite, buildSiteConfig, collectDocsPagesByTab, enforceChangelogDiagnostics, formatChangelogDiagnostic, rebuildMarkdownTabNavigation, resolveInternalLinks, } from "./site-assembly.js";
@@ -30,7 +31,12 @@ async function exists(path) {
     }
 }
 function log(msg) {
-    const t = new Date().toLocaleTimeString([], { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    const t = new Date().toLocaleTimeString([], {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
     console.log(`  \x1b[2m${t}\x1b[0m ${msg}`);
 }
 function shortPath(path) {
@@ -44,20 +50,22 @@ export async function startDevServer(options) {
         : resolve(options.config ?? process.cwd(), "sourcey.config.ts");
     const watchPaths = [configPath];
     for (const tab of config.tabs) {
-        if (tab.openapi)
-            watchPaths.push(tab.openapi);
-        if (tab.mcp)
-            watchPaths.push(tab.mcp);
-        if (tab.doxygen)
-            watchPaths.push(tab.doxygen.xml);
-        if (tab.godoc) {
-            if (tab.godoc.snapshot)
-                watchPaths.push(tab.godoc.snapshot);
+        watchPaths.push(...(tab.source.watchPaths ?? []));
+        if (tab.source.kind === "godoc") {
             // The Go module directory is large; watching every .go file slows the
             // dev server. Restart manually after broad source edits.
         }
-        if (tab.groups) {
-            for (const group of tab.groups) {
+        if (tab.source.kind === "rustdoc") {
+            // Cargo manifest is the watch surface; .rs files are intentionally not
+            // watched because rustdoc recompile is expensive. Restart manually
+            // after broad source edits, matching the godoc policy.
+            watchPaths.push(resolve(tab.source.config.manifest));
+            if (tab.source.config.snapshot) {
+                watchPaths.push(resolve(tab.source.config.snapshot));
+            }
+        }
+        if (tab.source.kind === "markdown") {
+            for (const group of tab.source.groups) {
                 for (const page of group.pages) {
                     watchPaths.push(page.file);
                 }
@@ -68,22 +76,48 @@ export async function startDevServer(options) {
         const map = new Map();
         map.set(configPath, { kind: "config" });
         for (const tab of cfg.tabs) {
-            if (tab.openapi) {
-                map.set(resolve(tab.openapi), { kind: "openapi", tabSlug: tab.slug, specPath: tab.openapi });
+            for (const watchPath of tab.source.watchPaths ?? []) {
+                map.set(resolve(watchPath), { kind: "config" });
+            }
+            if (tab.source.kind === "openapi") {
+                map.set(resolve(tab.source.spec), {
+                    kind: "openapi",
+                    tabSlug: tab.slug,
+                    specPath: tab.source.spec,
+                });
             }
-            if (tab.mcp) {
-                map.set(resolve(tab.mcp), { kind: "mcp", tabSlug: tab.slug, specPath: tab.mcp });
+            if (tab.source.kind === "mcp") {
+                map.set(resolve(tab.source.spec), {
+                    kind: "mcp",
+                    tabSlug: tab.slug,
+                    specPath: tab.source.spec,
+                });
+            }
+            if (tab.source.kind === "doxygen") {
+                map.set(resolve(tab.source.config.xml), {
+                    kind: "doxygen",
+                    tabSlug: tab.slug,
+                    xmlDir: tab.source.config.xml,
+                });
             }
-            if (tab.doxygen) {
-                map.set(resolve(tab.doxygen.xml), { kind: "doxygen", tabSlug: tab.slug, xmlDir: tab.doxygen.xml });
+            if (tab.source.kind === "godoc" && tab.source.config.snapshot) {
+                map.set(resolve(tab.source.config.snapshot), {
+                    kind: "godoc",
+                    tabSlug: tab.slug,
+                    snapshotPath: tab.source.config.snapshot,
+                });
             }
-            if (tab.godoc?.snapshot) {
-                map.set(resolve(tab.godoc.snapshot), { kind: "godoc", tabSlug: tab.slug, snapshotPath: tab.godoc.snapshot });
+            if (tab.source.kind === "rustdoc" && tab.source.config.snapshot) {
+                map.set(resolve(tab.source.config.snapshot), {
+                    kind: "rustdoc",
+                    tabSlug: tab.slug,
+                    snapshotPath: tab.source.config.snapshot,
+                });
             }
-            if (tab.groups) {
-                for (const group of tab.groups) {
+            if (tab.source.kind === "markdown") {
+                for (const group of tab.source.groups) {
                     for (const page of group.pages) {
-                        map.set(resolve(page.file), { kind: "markdown", tabSlug: tab.slug, pagePath: page.file, pageSlug: page.slug });
+                        map.set(resolve(page.file), { kind: "markdown", tabSlug: tab.slug, page });
                     }
                 }
             }
@@ -143,11 +177,13 @@ export async function startDevServer(options) {
         const { data } = snapshot;
         const start = performance.now();
         if (content.kind === "markdown") {
-            const slug = slugFromPath(content.pageSlug);
-            log(`reloading ${shortPath(content.pagePath)}`);
-            const page = await loadDocsPage(content.pagePath, slug, {
+            const slug = slugFromPath(content.page.slug);
+            log(`reloading ${shortPath(content.page.file)}`);
+            const page = await loadDocsPage(content.page.file, slug, {
                 changelog: config.changelog.enabled,
                 repoUrl: config.repo,
+                sourceRoot: content.page.sourceRoot,
+                preprocess: content.page.preprocess,
             });
             if (cache !== snapshot)
                 return;
@@ -166,10 +202,10 @@ export async function startDevServer(options) {
         }
         else if (content.kind === "doxygen") {
             const tab = config.tabs.find((candidate) => candidate.slug === content.tabSlug);
-            if (!tab?.doxygen)
+            if (!tab || tab.source.kind !== "doxygen")
                 return;
             log(`rebuilding doxygen tab "${tab.label}"`);
-            const { pages, navTab } = await loadDoxygenTab(tab.doxygen, tab.slug, tab.label);
+            const { pages, navTab } = await loadDoxygenTab(tab.source.config, tab.slug, tab.label);
             if (cache !== snapshot)
                 return;
             for (const [key, page] of data.pageMap) {
@@ -194,13 +230,45 @@ export async function startDevServer(options) {
         }
         else if (content.kind === "godoc") {
             const tab = config.tabs.find((candidate) => candidate.slug === content.tabSlug);
-            if (!tab?.godoc)
+            if (!tab || tab.source.kind !== "godoc")
                 return;
             log(`rebuilding godoc tab "${tab.label}"`);
-            const { pages, navTab } = await loadGodocTab(tab.godoc, tab.slug, tab.label, {
+            const { pages, navTab } = await loadGodocTab(tab.source.config, tab.slug, tab.label, {
+                repo: config.repo,
+                editBranch: config.editBranch,
+                editBasePath: tab.source.config.sourceBasePath,
+            });
+            if (cache !== snapshot)
+                return;
+            for (const [key, page] of data.pageMap) {
+                if (page.tabSlug === content.tabSlug)
+                    data.pageMap.delete(key);
+            }
+            for (const [slug, page] of pages) {
+                const outputPath = pageOutputPath(tab.slug, slug, config.prettyUrls);
+                data.pageMap.set(outputPath, {
+                    outputPath,
+                    spec: data.primarySpec,
+                    currentPage: { kind: "markdown", markdown: page },
+                    tabSlug: tab.slug,
+                    pageSlug: slug,
+                });
+            }
+            const idx = data.siteTabs.findIndex((candidate) => candidate.slug === content.tabSlug);
+            if (idx !== -1)
+                data.siteTabs[idx] = navTab;
+            else
+                data.siteTabs.push(navTab);
+        }
+        else if (content.kind === "rustdoc") {
+            const tab = config.tabs.find((candidate) => candidate.slug === content.tabSlug);
+            if (!tab || tab.source.kind !== "rustdoc")
+                return;
+            log(`rebuilding rustdoc tab "${tab.label}"`);
+            const { pages, navTab } = await loadRustdocTab(tab.source.config, tab.slug, tab.label, {
                 repo: config.repo,
                 editBranch: config.editBranch,
-                editBasePath: tab.godoc.sourceBasePath,
+                editBasePath: tab.source.config.sourceBasePath,
             });
             if (cache !== snapshot)
                 return;
@@ -280,7 +348,7 @@ export async function startDevServer(options) {
         return resolveConfigFromRaw(configMod.default, dirname(configPath));
     }
     async function render(url) {
-        const { renderPage } = await vite.ssrLoadModule(ssrRendererPath);
+        const { renderPage } = (await vite.ssrLoadModule(ssrRendererPath));
         const { data, siteConfig: site } = await getCached();
         const navigation = buildSiteNavigation(data.siteTabs);
         const requestPath = stripBaseUrl(new URL(url, "http://sourcey.local").pathname, config.baseUrl);
@@ -300,7 +368,10 @@ export async function startDevServer(options) {
             }
         }
         let pageData = data.pageMap.get(pagePath);
-        if (!pageData && config.prettyUrls === "slash" && pagePath.endsWith(".html") && !pagePath.endsWith("/index.html")) {
+        if (!pageData &&
+            config.prettyUrls === "slash" &&
+            pagePath.endsWith(".html") &&
+            !pagePath.endsWith("/index.html")) {
             // Fallback for stale `.html` links when prettyUrls is enabled.
             const pretty = pagePath.replace(/\.html$/, "/index.html");
             pageData = data.pageMap.get(pretty);
@@ -324,6 +395,10 @@ export async function startDevServer(options) {
         const docsPagesByTab = collectDocsPagesByTab(data.pageMap, config.tabs);
         return buildSearchIndex(data.specsBySlug, docsPagesByTab, navigation, config.baseUrl || "/", config.search.featured);
     }
+    async function loadExtraFileForDev(outputPath) {
+        const { data } = await getCached();
+        return data.extraFiles.get(outputPath);
+    }
     const viteConfig = {
         root: process.cwd(),
         server: {
@@ -343,6 +418,7 @@ export async function startDevServer(options) {
                 baseUrl: () => config.baseUrl,
                 render,
                 searchIndex: buildSearchIndexForDev,
+                extraFile: loadExtraFileForDev,
             }),
         ],
         clearScreen: false,

package/dist/index.d.ts

@@ -31,11 +31,15 @@ export interface SiteBuildResult {
     pageCount: number;
     changelogDiagnostics: ChangelogDiagnostic[];
     godocDiagnostics: import("./core/godoc-loader.js").GodocLoaderDiagnostic[];
+    rustdocDiagnostics: import("./core/rustdoc-loader.js").RustdocLoaderDiagnostic[];
     /** @internal specs by tab slug, for buildDocs compat */
     _specs?: Map<string, NormalizedSpec>;
 }
 export declare function buildSiteDocs(options?: SiteBuildOptions): Promise<SiteBuildResult>;
 export { defineConfig } from "./config.js";
+export { doxygen, godoc, markdown, mcp, mkdocs, openapi, rustdoc } from "./adapters/index.js";
 export { resolveInternalLinks } from "./site-assembly.js";
 export type { NormalizedSpec, NormalizedOperation, NormalizedTag, NormalizedSchema, NormalizedParameter, NormalizedRequestBody, NormalizedResponse, } from "./core/types.js";
+export type { DoxygenSourceOptions, GodocSourceOptions, MarkdownSourceOptions, McpSourceOptions, MkDocsSourceOptions, OpenApiSourceOptions, ResolvedTabSource, RustdocSourceOptions, SourceAdapter, SourceAdapterContext, } from "./adapters/index.js";
+export type { RustdocConfig, ResolvedRustdocConfig, RustdocMode, RustdocFeatures, } from "./config.js";
 //# sourceMappingURL=index.d.ts.map