@silicajs/core 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,16 +1,19 @@
+import {
+  formatPropertyLabel,
+  formatPropertyValue,
+  getMenuLabel,
+  getPageProperties
+} from "./chunk-HFUUGJO6.js";
 import {
   analyzeMarkdown,
   asFilePath,
   asFullSlug,
   asRelativeURL,
   asSimpleSlug,
-  formatPropertyLabel,
-  formatPropertyValue,
+  createWikiLinkResolutionIndex,
   generateDescriptionFromContent,
   getDescription,
-  getMenuLabel,
   getMetaDescription,
-  getPageProperties,
   getTitle,
   hasNumericPrefixInPath,
   hrefToSlug,
@@ -29,7 +32,7 @@ import {
   slugifySegment,
   stripNumericPrefix,
   tagToHref
-} from "./chunk-7KWXP3FM.js";
+} from "./chunk-BEINUFYU.js";
 
 // src/config.ts
 import path from "path";
@@ -103,9 +106,30 @@ function resolveConfig(config = {}, projectRoot = process.cwd()) {
     filters: {
       removeDrafts: config.filters?.removeDrafts ?? true,
       explicitPublish: config.filters?.explicitPublish ?? false
+    },
+    render: {
+      prerender: resolvePrerenderConfig(config.render?.prerender),
+      cache: {
+        storage: config.render?.cache?.storage ?? "filesystem",
+        directory: config.render?.cache?.directory
+      }
     }
   };
 }
+function resolvePrerenderConfig(prerender) {
+  if (!prerender || prerender === "all") return { strategy: "all" };
+  if (prerender === "none") return { strategy: "none" };
+  if ("strategy" in prerender && prerender.strategy === "all") {
+    return { ...prerender, strategy: "all" };
+  }
+  if ("strategy" in prerender && prerender.strategy === "none") {
+    return { ...prerender, strategy: "none" };
+  }
+  if ("strategy" in prerender && prerender.strategy === "custom") {
+    return { ...prerender, strategy: "custom" };
+  }
+  return { ...prerender, strategy: "depth" };
+}
 
 // src/files.ts
 import path2 from "path";
@@ -169,47 +193,312 @@ function isMarkdownFile(filePath) {
 // src/precompute.ts
 import crypto from "crypto";
 import { execFile } from "child_process";
-import path3 from "path";
+import os from "os";
+import path4 from "path";
 import { promisify } from "util";
+import { Worker } from "worker_threads";
+import fs3 from "fs-extra";
+
+// src/vault-db.ts
+import path3 from "path";
+import Database from "better-sqlite3";
 import fs2 from "fs-extra";
 import {
-  buildSearchDatabase,
-  SEARCH_DATABASE_FILENAME
+  buildSearchTables,
+  makeExcerpt
 } from "@silicajs/search";
+var VAULT_DATABASE_FILENAME = "vault.db";
+var VAULT_DATABASE_VERSION = "1";
+async function writeVaultDatabase(projectRoot, input) {
+  const silicaRoot = path3.join(projectRoot, ".silica");
+  await fs2.ensureDir(silicaRoot);
+  const databasePath = path3.join(silicaRoot, VAULT_DATABASE_FILENAME);
+  const temporaryPath = path3.join(silicaRoot, `${VAULT_DATABASE_FILENAME}.tmp`);
+  await removeDatabaseFiles(temporaryPath);
+  const db = new Database(temporaryPath);
+  try {
+    db.pragma("journal_mode = DELETE");
+    db.pragma("foreign_keys = ON");
+    db.pragma("synchronous = OFF");
+    createVaultDatabaseSchema(db);
+    populateVaultDatabase(db, input);
+    db.exec("VACUUM");
+  } finally {
+    db.close();
+  }
+  await removeDatabaseFiles(databasePath);
+  await fs2.rename(temporaryPath, databasePath);
+  await removeDatabaseSidecars(temporaryPath);
+  return databasePath;
+}
+function createVaultDatabaseSchema(db) {
+  db.exec(`
+    CREATE TABLE vault_metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE notes (
+      slug TEXT PRIMARY KEY,
+      file TEXT NOT NULL,
+      relative_file TEXT NOT NULL,
+      title TEXT NOT NULL,
+      menu_label TEXT NOT NULL,
+      description TEXT,
+      generated_description TEXT,
+      frontmatter_json TEXT NOT NULL,
+      tags_json TEXT NOT NULL,
+      search_excerpt TEXT NOT NULL DEFAULT '',
+      created TEXT,
+      modified TEXT,
+      sort_key TEXT,
+      listed INTEGER NOT NULL,
+      content_hash TEXT NOT NULL,
+      render_hash TEXT NOT NULL,
+      prerender INTEGER NOT NULL
+    );
+
+    CREATE TABLE note_tags (
+      slug TEXT NOT NULL,
+      tag TEXT NOT NULL,
+      PRIMARY KEY (slug, tag),
+      FOREIGN KEY (slug) REFERENCES notes(slug) ON DELETE CASCADE
+    );
+
+    CREATE TABLE links (
+      source_slug TEXT NOT NULL,
+      target_slug TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('link', 'embed')),
+      PRIMARY KEY (source_slug, target_slug, kind)
+    );
+
+    CREATE TABLE broken_links (
+      source_slug TEXT NOT NULL,
+      target TEXT NOT NULL
+    );
+
+    CREATE TABLE slug_aliases (
+      strategy_key TEXT NOT NULL,
+      alias TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      sort_key TEXT,
+      PRIMARY KEY (strategy_key, alias, slug)
+    );
+
+    CREATE INDEX notes_prerender_idx ON notes(prerender, slug);
+    CREATE INDEX notes_listed_sort_idx ON notes(listed, sort_key, slug);
+    CREATE INDEX links_target_idx ON links(target_slug, kind, source_slug);
+    CREATE INDEX links_source_idx ON links(source_slug, kind, target_slug);
+    CREATE INDEX note_tags_tag_idx ON note_tags(tag, slug);
+    CREATE INDEX slug_aliases_lookup_idx
+      ON slug_aliases(strategy_key, alias, sort_key, slug);
+  `);
+}
+function populateVaultDatabase(db, input) {
+  const prerenderSlugs = new Set(input.prerender.slugs);
+  const searchBySlug = new Map(
+    input.searchRecords.map((record) => [record.slug, record])
+  );
+  const insertMetadata = db.prepare(`
+    INSERT INTO vault_metadata (key, value) VALUES (?, ?)
+  `);
+  const insertNote = db.prepare(`
+    INSERT INTO notes (
+      slug,
+      file,
+      relative_file,
+      title,
+      menu_label,
+      description,
+      generated_description,
+      frontmatter_json,
+      tags_json,
+      search_excerpt,
+      created,
+      modified,
+      sort_key,
+      listed,
+      content_hash,
+      render_hash,
+      prerender
+    )
+    VALUES (
+      @slug,
+      @file,
+      @relativeFile,
+      @title,
+      @menuLabel,
+      @description,
+      @generatedDescription,
+      @frontmatterJson,
+      @tagsJson,
+      @searchExcerpt,
+      @created,
+      @modified,
+      @sortKey,
+      @listed,
+      @contentHash,
+      @renderHash,
+      @prerender
+    )
+  `);
+  const insertTag = db.prepare(`
+    INSERT OR IGNORE INTO note_tags (slug, tag) VALUES (?, ?)
+  `);
+  const insertLink = db.prepare(`
+    INSERT OR IGNORE INTO links (source_slug, target_slug, kind)
+    VALUES (?, ?, ?)
+  `);
+  const insertBrokenLink = db.prepare(`
+    INSERT INTO broken_links (source_slug, target) VALUES (?, ?)
+  `);
+  const insertAlias = db.prepare(`
+    INSERT OR IGNORE INTO slug_aliases (strategy_key, alias, slug, sort_key)
+    VALUES (?, ?, ?, ?)
+  `);
+  const insertAll = db.transaction(() => {
+    insertMetadata.run("version", VAULT_DATABASE_VERSION);
+    insertMetadata.run("generatedAt", input.manifest.generatedAt);
+    insertMetadata.run("contentDir", input.manifest.contentDir);
+    insertMetadata.run("configJson", JSON.stringify(input.config));
+    insertMetadata.run(
+      "renderEnvironmentHash",
+      input.cacheState.renderEnvironmentHash
+    );
+    insertMetadata.run("configHash", input.cacheState.configHash);
+    insertMetadata.run("navigationHash", input.cacheState.navigationHash);
+    insertMetadata.run("tagIndexHash", input.cacheState.tagIndexHash);
+    insertMetadata.run("rendererVersion", input.cacheState.rendererVersion);
+    insertMetadata.run("cacheStateJson", JSON.stringify(input.cacheState));
+    for (const entry of input.manifest.entries) {
+      const searchRecord = searchBySlug.get(entry.slug);
+      insertNote.run({
+        slug: entry.slug,
+        file: entry.file,
+        relativeFile: entry.relativeFile,
+        title: entry.title,
+        menuLabel: entry.menuLabel,
+        description: entry.description,
+        generatedDescription: entry.generatedDescription,
+        frontmatterJson: JSON.stringify(entry.frontmatter),
+        tagsJson: JSON.stringify(entry.tags),
+        searchExcerpt: searchRecord ? makeExcerpt(
+          searchRecord.content,
+          searchRecord.description ?? searchRecord.title
+        ) : "",
+        created: entry.created,
+        modified: entry.modified,
+        sortKey: entry.sortKey,
+        listed: isListedEntry(entry) ? 1 : 0,
+        contentHash: entry.contentHash,
+        renderHash: input.renderHashes[entry.slug] ?? "missing",
+        prerender: prerenderSlugs.has(entry.slug) ? 1 : 0
+      });
+      for (const tag of entry.tags) {
+        for (const hierarchyTag of tagHierarchy(tag)) {
+          insertTag.run(entry.slug, hierarchyTag);
+        }
+      }
+    }
+    for (const [source, targets] of Object.entries(input.graph.links)) {
+      for (const target of targets) {
+        insertLink.run(source, target, "link");
+      }
+    }
+    for (const entry of input.manifest.entries) {
+      for (const target of entry.embeds) {
+        insertLink.run(entry.slug, target, "embed");
+      }
+    }
+    for (const brokenLink of input.graph.brokenLinks) {
+      insertBrokenLink.run(brokenLink.source, brokenLink.target);
+    }
+    for (const entry of input.manifest.entries) {
+      for (const [strategy, alias] of makeSlugAliases(entry.slug)) {
+        insertAlias.run(
+          strategy,
+          alias,
+          entry.slug,
+          entry.sortKey ?? entry.slug
+        );
+      }
+    }
+  });
+  insertAll();
+  buildSearchTables(db, input.searchRecords);
+}
+function isListedEntry(entry) {
+  return entry.frontmatter.listed !== false;
+}
+function tagHierarchy(tag) {
+  const normalized = tag.trim().replace(/^#/, "").toLowerCase();
+  const segments = normalized.split("/").filter(Boolean);
+  return segments.map((_, index) => segments.slice(0, index + 1).join("/"));
+}
+function makeSlugAliases(slug) {
+  const aliases = /* @__PURE__ */ new Map();
+  const simplified = slug === "index" ? "" : slug.replace(/\/index$/, "");
+  const basename = simplified.split("/").at(-1) ?? "";
+  aliases.set(`absolute:${slug}`, slug);
+  if (simplified) aliases.set(`absolute:${simplified}`, simplified);
+  if (basename) aliases.set(`shortest:${basename}`, basename);
+  return [...aliases.entries()].map(([key, alias]) => [
+    key.split(":")[0] ?? "shortest",
+    alias
+  ]);
+}
+async function removeDatabaseFiles(databasePath) {
+  await fs2.remove(databasePath);
+  await removeDatabaseSidecars(databasePath);
+}
+async function removeDatabaseSidecars(databasePath) {
+  await Promise.all([
+    fs2.remove(`${databasePath}-wal`),
+    fs2.remove(`${databasePath}-shm`),
+    fs2.remove(`${databasePath}-journal`)
+  ]);
+}
+
+// src/precompute.ts
 var execFileAsync = promisify(execFile);
+var MIN_PARALLEL_ANALYSIS_FILES = 64;
+var ANALYSIS_BATCH_SIZE = 16;
+var MAX_ANALYSIS_WORKERS = 12;
+var RENDER_CACHE_SCHEMA_VERSION = "silica-render-v1";
 async function precompute(options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
   const config = options.config ?? await loadConfig(projectRoot);
   const scan = await scanContent(projectRoot, config);
   const markdownFiles = filterPublished(scan.markdown, config);
   const allSlugs = markdownFiles.map((file) => file.slug);
+  const wikilinkIndex = createWikiLinkResolutionIndex(
+    allSlugs,
+    config.ordering
+  );
   const entries = [];
   const graphLinks = {};
   const brokenLinks = [];
   const searchRecords = [];
-  const runtimeContentRoot = path3.join(projectRoot, ".silica/content");
+  const runtimeContentRoot = path4.join(projectRoot, ".silica/content");
   const relativeGitPaths = markdownFiles.map(
-    (file) => normalizeGitPath(path3.join(config.contentDir, file.relativePath))
+    (file) => normalizeGitPath(path4.join(config.contentDir, file.relativePath))
   );
   const gitDatesByPath = await getGitDatesForFiles(
     projectRoot,
     relativeGitPaths
   );
-  await fs2.ensureDir(path3.join(projectRoot, ".silica"));
-  await fs2.ensureDir(path3.join(projectRoot, ".silica/next/public/silica"));
+  await fs3.ensureDir(path4.join(projectRoot, ".silica"));
+  await fs3.ensureDir(path4.join(projectRoot, ".silica/next/public/silica"));
   await writeRuntimeMarkdown(runtimeContentRoot, markdownFiles);
-  for (const file of markdownFiles) {
+  const analyses = await analyzeMarkdownFiles(markdownFiles, config, allSlugs, {
+    concurrency: options.analysisConcurrency,
+    wikilinkIndex
+  });
+  for (const [index, file] of markdownFiles.entries()) {
     const gitDates = gitDatesByPath.get(
-      normalizeGitPath(path3.join(config.contentDir, file.relativePath))
+      normalizeGitPath(path4.join(config.contentDir, file.relativePath))
     ) ?? {};
-    const analysis = await analyzeMarkdown(file.raw, {
-      slug: asFullSlug(file.slug),
-      allSlugs,
-      assetBaseUrl: "/silica",
-      wikilinkStrategy: config.wikilinks.strategy,
-      tags: config.tags,
-      ordering: config.ordering
-    });
+    const analysis = analyses[index];
     const title = analysis.title ?? titleFromFilePath(file.relativePath, config.ordering);
     const menuLabel = getMenuLabel(file.frontmatter, title);
     const sortKey = config.ordering.numericPrefixes && hasNumericPrefixInPath(file.relativePath) ? numericPrefixSortKey(file.relativePath) : void 0;
@@ -220,7 +509,7 @@ async function precompute(options = {}) {
       description: analysis.description,
       generatedDescription: analysis.generatedDescription,
       tags: analysis.tags,
-      file: normalizeGitPath(path3.join(".silica/content", file.relativePath)),
+      file: normalizeGitPath(path4.join(".silica/content", file.relativePath)),
       relativeFile: file.relativePath,
       sortKey,
       created: stringifyDate(
@@ -229,12 +518,14 @@ async function precompute(options = {}) {
       modified: stringifyDate(
         getDate(file.frontmatter.modified) ?? gitDates.modified ?? file.stats.mtime
       ),
-      frontmatter: file.frontmatter
+      frontmatter: file.frontmatter,
+      contentHash: hashString(file.raw),
+      embeds: analysis.embeds
     };
     entries.push(entry);
     graphLinks[file.slug] = analysis.links;
     brokenLinks.push(...analysis.brokenLinks);
-    if (isListedEntry(entry)) {
+    if (isListedEntry2(entry)) {
       searchRecords.push({
         id: file.slug,
         slug: file.slug,
@@ -248,27 +539,18 @@ async function precompute(options = {}) {
   await copyAssets(projectRoot, config, scan.assets);
   const manifest = makeManifest(config, entries);
   const graph = makeGraph(graphLinks, brokenLinks);
-  const buildId = crypto.randomUUID();
-  await buildSearchDatabase(
-    searchRecords,
-    path3.join(projectRoot, ".silica", SEARCH_DATABASE_FILENAME)
-  );
-  await fs2.remove(path3.join(projectRoot, ".silica/search-index.json"));
-  await writeJson(
-    path3.join(projectRoot, ".silica/manifest.json"),
-    serializeManifest(manifest)
-  );
-  await writeJson(
-    path3.join(projectRoot, ".silica/navigation.json"),
-    makeNavigation(manifest)
-  );
-  await writeJson(path3.join(projectRoot, ".silica/graph.json"), graph);
-  await writeJson(path3.join(projectRoot, ".silica/config.json"), config);
-  await fs2.writeFile(
-    path3.join(projectRoot, ".silica/build-id.txt"),
-    `${buildId}
-`
-  );
+  const renderHashes = makeRenderHashes(manifest, graph);
+  const cacheState = await makeRenderCacheState(projectRoot, config, manifest);
+  const prerender = makePrerenderManifest(manifest, graph, config);
+  await writeVaultDatabase(projectRoot, {
+    config,
+    manifest,
+    graph,
+    renderHashes,
+    cacheState,
+    prerender,
+    searchRecords
+  });
   await writeSitemapAndRobots(projectRoot, config, manifest);
   if (config.wikilinks.strict && brokenLinks.length > 0) {
     const message = brokenLinks.map((link) => `${link.source} -> ${link.target}`).join("\n");
@@ -279,36 +561,304 @@ ${message}`);
     manifest,
     graph,
     searchRecords,
-    buildId,
+    prerender,
+    cacheState,
     brokenLinks
   };
 }
+async function analyzeMarkdownFiles(files, config, allSlugs, options) {
+  const workerCount = getAnalysisWorkerCount(files.length, options.concurrency);
+  if (workerCount <= 1) {
+    return analyzeMarkdownFilesSerial(files, config, options.wikilinkIndex);
+  }
+  return analyzeMarkdownFilesParallel(files, config, allSlugs, workerCount);
+}
+async function analyzeMarkdownFilesSerial(files, config, wikilinkIndex) {
+  const analyses = [];
+  for (const file of files) {
+    analyses.push(
+      await analyzeMarkdown(file.raw, {
+        slug: asFullSlug(file.slug),
+        wikilinkIndex,
+        assetBaseUrl: "/silica",
+        wikilinkStrategy: config.wikilinks.strategy,
+        tags: config.tags,
+        ordering: config.ordering
+      })
+    );
+  }
+  return analyses;
+}
+function analyzeMarkdownFilesParallel(files, config, allSlugs, workerCount) {
+  return new Promise((resolve, reject) => {
+    const workerUrl = new URL("./precompute-worker.js", import.meta.url);
+    const workers = [];
+    const analyses = new Array(files.length);
+    let nextIndex = 0;
+    let completed = 0;
+    let settled = false;
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      for (const worker of workers) {
+        void worker.terminate();
+      }
+      reject(error);
+    };
+    const resolveIfDone = () => {
+      if (completed < files.length || settled) return;
+      settled = true;
+      for (const worker of workers) {
+        void worker.terminate();
+      }
+      resolve(analyses);
+    };
+    const sendNext = (worker) => {
+      if (settled || nextIndex >= files.length) return;
+      const start = nextIndex;
+      const batch = files.slice(start, start + ANALYSIS_BATCH_SIZE).map((file, offset) => ({
+        index: start + offset,
+        slug: file.slug,
+        raw: file.raw
+      }));
+      nextIndex += batch.length;
+      worker.postMessage({
+        id: start,
+        files: batch
+      });
+    };
+    for (let index = 0; index < workerCount; index += 1) {
+      const worker = new Worker(workerUrl, {
+        workerData: {
+          allSlugs,
+          wikilinkStrategy: config.wikilinks.strategy,
+          tags: config.tags,
+          ordering: config.ordering
+        }
+      });
+      workers.push(worker);
+      worker.on("message", (message) => {
+        if (message.error) {
+          rejectOnce(new Error(message.error));
+          return;
+        }
+        for (const result of message.results ?? []) {
+          analyses[result.index] = result.analysis;
+        }
+        completed += message.results?.length ?? 0;
+        resolveIfDone();
+        sendNext(worker);
+      });
+      worker.on("error", rejectOnce);
+      worker.on("exit", (code) => {
+        if (!settled && code !== 0) {
+          rejectOnce(
+            new Error(`Precompute analysis worker exited with ${code}`)
+          );
+        }
+      });
+      sendNext(worker);
+    }
+  });
+}
+function getAnalysisWorkerCount(fileCount, requestedConcurrency) {
+  if (fileCount === 0) return 1;
+  if (requestedConcurrency === void 0 && fileCount < MIN_PARALLEL_ANALYSIS_FILES) {
+    return 1;
+  }
+  const available = Math.max(
+    1,
+    os.availableParallelism?.() ?? os.cpus().length
+  );
+  const requested = getRequestedAnalysisConcurrency(
+    requestedConcurrency,
+    available
+  );
+  const usefulWorkers = Math.ceil(fileCount / ANALYSIS_BATCH_SIZE);
+  return Math.max(1, Math.min(fileCount, requested, usefulWorkers));
+}
+function getRequestedAnalysisConcurrency(requestedConcurrency, available) {
+  if (requestedConcurrency === void 0) {
+    return Math.min(available, MAX_ANALYSIS_WORKERS);
+  }
+  if (!Number.isFinite(requestedConcurrency)) return 1;
+  return Math.max(1, Math.floor(requestedConcurrency));
+}
 async function writeRuntimeMarkdown(runtimeContentRoot, files) {
-  await fs2.emptyDir(runtimeContentRoot);
+  await fs3.emptyDir(runtimeContentRoot);
   for (const file of files) {
-    const destination = path3.join(runtimeContentRoot, file.relativePath);
-    await fs2.ensureDir(path3.dirname(destination));
-    await fs2.writeFile(destination, file.raw);
+    const destination = path4.join(runtimeContentRoot, file.relativePath);
+    await fs3.ensureDir(path4.dirname(destination));
+    await fs3.writeFile(destination, file.raw);
   }
 }
-function serializeManifest(manifest) {
+async function makeRenderCacheState(projectRoot, config, manifest) {
+  const themeHash = await getThemeHash(projectRoot, config.theme);
+  const configHash = hashStable({
+    title: config.title,
+    description: config.description,
+    logo: config.logo,
+    baseUrl: config.baseUrl,
+    contentDir: config.contentDir,
+    theme: config.theme,
+    auth: config.auth,
+    wikilinks: config.wikilinks,
+    tags: config.tags,
+    ordering: config.ordering,
+    filters: config.filters
+  });
+  const navigationHash = hashStable({
+    entries: manifest.entries.filter(isListedEntry2).map((entry) => ({
+      slug: entry.slug,
+      menuLabel: entry.menuLabel,
+      sortKey: entry.sortKey
+    }))
+  });
+  const tagIndexHash = hashStable({
+    entries: manifest.entries.filter(isListedEntry2).map((entry) => ({
+      slug: entry.slug,
+      title: entry.title,
+      description: entry.description,
+      tags: entry.tags
+    }))
+  });
   return {
-    version: manifest.version,
-    generatedAt: manifest.generatedAt,
-    contentDir: manifest.contentDir,
-    entries: manifest.entries
+    version: 1,
+    renderEnvironmentHash: hashStable({
+      version: RENDER_CACHE_SCHEMA_VERSION,
+      configHash,
+      themeHash
+    }),
+    configHash,
+    navigationHash,
+    tagIndexHash,
+    themeHash,
+    rendererVersion: RENDER_CACHE_SCHEMA_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function makeNavigation(manifest) {
+function makeRenderHashes(manifest, graph) {
+  const memo = /* @__PURE__ */ new Map();
+  const renderHashForSlug = (slug, seen = /* @__PURE__ */ new Set()) => {
+    const cached = memo.get(slug);
+    if (cached) return cached;
+    const entry = manifest.bySlug[slug];
+    if (!entry) return hashStable({ missing: slug });
+    if (seen.has(slug)) {
+      return hashStable({ slug, contentHash: entry.contentHash, cycle: true });
+    }
+    const nextSeen = new Set(seen).add(slug);
+    const embedded = entry.embeds.map((target) => ({
+      slug: target,
+      renderHash: renderHashForSlug(target, nextSeen)
+    }));
+    const backlinks = (graph.backlinks[slug] ?? []).map((source) => ({
+      slug: source,
+      title: manifest.bySlug[source]?.title ?? source
+    }));
+    const renderHash = hashStable({
+      entry: {
+        slug: entry.slug,
+        title: entry.title,
+        menuLabel: entry.menuLabel,
+        description: entry.description,
+        generatedDescription: entry.generatedDescription,
+        tags: entry.tags,
+        relativeFile: entry.relativeFile,
+        sortKey: entry.sortKey,
+        created: entry.created,
+        modified: entry.modified,
+        frontmatter: entry.frontmatter,
+        contentHash: entry.contentHash
+      },
+      embedded,
+      backlinks
+    });
+    memo.set(slug, renderHash);
+    return renderHash;
+  };
+  for (const slug of manifest.allSlugs) {
+    renderHashForSlug(slug);
+  }
+  return Object.fromEntries(memo);
+}
+function makePrerenderManifest(manifest, graph, config) {
   return {
     version: 1,
-    entries: manifest.entries.filter(isListedEntry).map((entry) => ({
-      slug: entry.slug,
-      title: entry.menuLabel,
-      sortKey: entry.sortKey
-    }))
+    slugs: selectPrerenderSlugs(manifest, graph, config)
   };
 }
+function selectPrerenderSlugs(manifest, graph, config) {
+  const prerender = config.render.prerender;
+  const entries = manifest.entries;
+  const scoreBySlug = /* @__PURE__ */ new Map();
+  let candidates = [];
+  if (prerender.strategy === "all") {
+    candidates = entries;
+  } else if (prerender.strategy === "depth") {
+    candidates = entries.filter(
+      (entry) => entry.slug === "index" || getSlugDepth(entry.slug) <= prerender.depth
+    );
+  } else if (prerender.strategy === "custom") {
+    const context = { manifest, graph };
+    candidates = entries.filter((entry) => {
+      const selected2 = prerender.select?.(entry, context);
+      if (typeof selected2 === "number" && Number.isFinite(selected2)) {
+        scoreBySlug.set(entry.slug, selected2);
+        return true;
+      }
+      return selected2 === true;
+    });
+  }
+  const selected = new Set(
+    [...candidates].sort((left, right) => {
+      const scoreDelta = (scoreBySlug.get(right.slug) ?? 0) - (scoreBySlug.get(left.slug) ?? 0);
+      return scoreDelta || compareManifestEntries(left, right);
+    }).slice(0, prerender.limit ?? candidates.length).map((entry) => entry.slug)
+  );
+  for (const slug of prerender.include ?? []) {
+    if (manifest.bySlug[slug]) selected.add(slug);
+  }
+  for (const slug of prerender.exclude ?? []) {
+    selected.delete(slug);
+  }
+  return manifest.entries.map((entry) => entry.slug).filter((slug) => selected.has(slug));
+}
+function getSlugDepth(slug) {
+  const segments = slug.split("/").filter(Boolean);
+  return Math.max(0, segments.length - 1);
+}
+async function getThemeHash(projectRoot, theme) {
+  const themeName = getThemeName(theme);
+  if (!themeName?.startsWith(".")) return void 0;
+  const themeRoot = path4.resolve(projectRoot, themeName);
+  if (!await fs3.pathExists(themeRoot)) return void 0;
+  const files = await readThemeFiles(themeRoot);
+  return hashStable(files);
+}
+function getThemeName(theme) {
+  if (typeof theme === "string") return theme;
+  if (typeof theme === "object" && theme !== null) return theme.name;
+  return void 0;
+}
+async function readThemeFiles(root, current = root) {
+  const entries = await fs3.readdir(current, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries.sort(
+    (left, right) => left.name.localeCompare(right.name)
+  )) {
+    const absolutePath = path4.join(current, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await readThemeFiles(root, absolutePath));
+    } else if (entry.isFile()) {
+      results.push({
+        path: normalizeGitPath(path4.relative(root, absolutePath)),
+        content: await fs3.readFile(absolutePath, "utf8")
+      });
+    }
+  }
+  return results;
+}
 async function getGitDates(projectRoot, relativePath) {
   return (await getGitDatesForFiles(projectRoot, [normalizeGitPath(relativePath)])).get(normalizeGitPath(relativePath)) ?? {};
 }
@@ -349,6 +899,26 @@ async function getGitDatesForFiles(projectRoot, relativePaths) {
 function normalizeGitPath(relativePath) {
   return relativePath.replace(/\\/g, "/");
 }
+function hashString(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+function hashStable(value) {
+  return hashString(stableStringify(value));
+}
+function stableStringify(value) {
+  if (value === void 0) return "undefined";
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, entryValue]) => typeof entryValue !== "function").sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(
+      ([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`
+    ).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
 function filterPublished(files, config) {
   return files.filter((file) => {
     if (config.filters.removeDrafts && file.frontmatter.draft === true)
@@ -400,33 +970,33 @@ function makeGraph(links, brokenLinks) {
   };
 }
 async function copyAssets(projectRoot, config, assets) {
-  const destinationRoot = path3.join(projectRoot, ".silica/next/public/silica");
-  await fs2.emptyDir(destinationRoot);
+  const destinationRoot = path4.join(projectRoot, ".silica/next/public/silica");
+  await fs3.emptyDir(destinationRoot);
   for (const asset of assets) {
-    await fs2.ensureDir(
-      path3.dirname(path3.join(destinationRoot, asset.relativePath))
+    await fs3.ensureDir(
+      path4.dirname(path4.join(destinationRoot, asset.relativePath))
     );
-    await fs2.copyFile(
+    await fs3.copyFile(
       asset.absolutePath,
-      path3.join(destinationRoot, asset.relativePath)
+      path4.join(destinationRoot, asset.relativePath)
     );
   }
-  await fs2.ensureDir(path3.join(projectRoot, ".silica/next/public"));
-  await fs2.writeFile(path3.join(destinationRoot, ".gitkeep"), "");
+  await fs3.ensureDir(path4.join(projectRoot, ".silica/next/public"));
+  await fs3.writeFile(path4.join(destinationRoot, ".gitkeep"), "");
 }
 async function writeSitemapAndRobots(projectRoot, config, manifest) {
-  const publicRoot = path3.join(projectRoot, ".silica/next/public");
-  await fs2.ensureDir(publicRoot);
+  const publicRoot = path4.join(projectRoot, ".silica/next/public");
+  await fs3.ensureDir(publicRoot);
   const baseUrl = (config.baseUrl ?? "http://localhost:3000").replace(
     /\/$/,
     ""
   );
-  const urls = manifest.entries.filter(isListedEntry).map(
+  const urls = manifest.entries.filter(isListedEntry2).map(
     (entry) => `  <url><loc>${baseUrl}${slugToHref(entry.slug)}</loc></url>`
   ).join("\n");
-  if (!await fs2.pathExists(path3.join(projectRoot, "public/sitemap.xml"))) {
-    await fs2.writeFile(
-      path3.join(publicRoot, "sitemap.xml"),
+  if (!await fs3.pathExists(path4.join(projectRoot, "public/sitemap.xml"))) {
+    await fs3.writeFile(
+      path4.join(publicRoot, "sitemap.xml"),
       `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${urls}
@@ -434,9 +1004,9 @@ ${urls}
 `
     );
   }
-  if (!await fs2.pathExists(path3.join(projectRoot, "public/robots.txt"))) {
-    await fs2.writeFile(
-      path3.join(publicRoot, "robots.txt"),
+  if (!await fs3.pathExists(path4.join(projectRoot, "public/robots.txt"))) {
+    await fs3.writeFile(
+      path4.join(publicRoot, "robots.txt"),
       `User-agent: *
 Allow: /
 Sitemap: ${baseUrl}/sitemap.xml
@@ -444,10 +1014,6 @@ Sitemap: ${baseUrl}/sitemap.xml
     );
   }
 }
-async function writeJson(filePath, value) {
-  await fs2.ensureDir(path3.dirname(filePath));
-  await fs2.writeJson(filePath, value, { spaces: 2 });
-}
 function getDate(value) {
   if (value instanceof Date) return value;
   if (typeof value === "string" || typeof value === "number") {
@@ -456,14 +1022,14 @@ function getDate(value) {
   }
   return void 0;
 }
-function isListedEntry(entry) {
+function isListedEntry2(entry) {
   return entry.frontmatter.listed !== false;
 }
 function stringifyDate(value) {
   return value?.toISOString();
 }
 function titleFromFilePath(relativePath, ordering) {
-  const stem = path3.posix.basename(normalizeGitPath(relativePath)).replace(/\.(md|markdown|mdx)$/i, "");
+  const stem = path4.posix.basename(normalizeGitPath(relativePath)).replace(/\.(md|markdown|mdx)$/i, "");
   const title = ordering.numericPrefixes ? stripNumericPrefix(stem) : stem;
   return /^index$/i.test(title) ? "Home" : title;
 }
@@ -473,6 +1039,7 @@ export {
   asFullSlug,
   asRelativeURL,
   asSimpleSlug,
+  createWikiLinkResolutionIndex,
   defineConfig,
   formatPropertyLabel,
   formatPropertyValue,