@limcpf/everything-is-a-markdown 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limcpf/everything-is-a-markdown",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
   "bin": {

package/src/build.ts

@@ -20,13 +20,31 @@ import {
   toRoute,
 } from "./utils";
 
-const CACHE_VERSION = 1;
+const CACHE_VERSION = 2;
 const CACHE_DIR_NAME = ".cache";
 const CACHE_FILE_NAME = "build-index.json";
 const DEFAULT_BRANCH = "dev";
 const DEFAULT_SITE_DESCRIPTION = "File-system style static blog with markdown explorer UI.";
 const DEFAULT_SITE_TITLE = "File-System Blog";
 
+type CachedSourceEntry = BuildCache["sources"][string];
+
+interface OutputWriteContext {
+  outDir: string;
+  previousHashes: Record<string, string>;
+  nextHashes: Record<string, string>;
+}
+
+interface WikiLookup {
+  byPath: Map<string, DocRecord>;
+  byStem: Map<string, DocRecord[]>;
+}
+
+interface ReadDocsResult {
+  docs: DocRecord[];
+  nextSources: BuildCache["sources"];
+}
+
 interface BuildResult {
   totalDocs: number;
   renderedDocs: number;
@@ -41,20 +59,130 @@ function toCachePath(): string {
   return path.join(process.cwd(), CACHE_DIR_NAME, CACHE_FILE_NAME);
 }
 
+function createEmptyCache(): BuildCache {
+  return { version: CACHE_VERSION, sources: {}, docs: {}, outputHashes: {} };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function normalizeCachedDocIndex(value: unknown): BuildCache["docs"] {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const normalized: BuildCache["docs"] = {};
+  for (const [id, rawEntry] of Object.entries(value)) {
+    if (!isRecord(rawEntry)) {
+      continue;
+    }
+
+    const hash = typeof rawEntry.hash === "string" ? rawEntry.hash : "";
+    const route = typeof rawEntry.route === "string" ? rawEntry.route : "";
+    const relPath = typeof rawEntry.relPath === "string" ? rawEntry.relPath : "";
+    if (!hash || !route || !relPath) {
+      continue;
+    }
+
+    normalized[id] = { hash, route, relPath };
+  }
+
+  return normalized;
+}
+
+function normalizeCachedOutputHashes(value: unknown): BuildCache["outputHashes"] {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const normalized: BuildCache["outputHashes"] = {};
+  for (const [outputPath, hash] of Object.entries(value)) {
+    if (typeof hash === "string" && hash.length > 0) {
+      normalized[outputPath] = hash;
+    }
+  }
+  return normalized;
+}
+
+function normalizeCachedSourceEntry(value: unknown): CachedSourceEntry | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+
+  const mtimeMs = typeof value.mtimeMs === "number" && Number.isFinite(value.mtimeMs) ? value.mtimeMs : null;
+  const size = typeof value.size === "number" && Number.isFinite(value.size) ? value.size : null;
+  const rawHash = typeof value.rawHash === "string" ? value.rawHash : "";
+  const publish = value.publish === true;
+  const draft = value.draft === true;
+  const title = typeof value.title === "string" && value.title.trim().length > 0 ? value.title.trim() : undefined;
+  const date = typeof value.date === "string" && value.date.trim().length > 0 ? value.date.trim() : undefined;
+  const updatedDate =
+    typeof value.updatedDate === "string" && value.updatedDate.trim().length > 0 ? value.updatedDate.trim() : undefined;
+  const description =
+    typeof value.description === "string" && value.description.trim().length > 0 ? value.description.trim() : undefined;
+  const tags = parseStringArray(value.tags);
+  const branch = parseBranch(value.branch);
+  const body = typeof value.body === "string" ? value.body : null;
+  const wikiTargets = parseStringArray(value.wikiTargets);
+
+  if (mtimeMs === null || size === null || !rawHash || body == null) {
+    return null;
+  }
+
+  return {
+    mtimeMs,
+    size,
+    rawHash,
+    publish,
+    draft,
+    title,
+    date,
+    updatedDate,
+    description,
+    tags,
+    branch,
+    body,
+    wikiTargets,
+  };
+}
+
+function normalizeCachedSources(value: unknown): BuildCache["sources"] {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const normalized: BuildCache["sources"] = {};
+  for (const [relPath, rawEntry] of Object.entries(value)) {
+    const entry = normalizeCachedSourceEntry(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    normalized[relPath] = entry;
+  }
+  return normalized;
+}
+
 async function readCache(cachePath: string): Promise<BuildCache> {
   const file = Bun.file(cachePath);
   if (!(await file.exists())) {
-    return { version: CACHE_VERSION, docs: {} };
+    return createEmptyCache();
   }
 
   try {
-    const parsed = (await file.json()) as BuildCache;
-    if (parsed.version !== CACHE_VERSION || typeof parsed.docs !== "object" || !parsed.docs) {
-      return { version: CACHE_VERSION, docs: {} };
+    const parsed = (await file.json()) as unknown;
+    if (!isRecord(parsed) || parsed.version !== CACHE_VERSION) {
+      return createEmptyCache();
     }
-    return parsed;
+
+    return {
+      version: CACHE_VERSION,
+      sources: normalizeCachedSources(parsed.sources),
+      docs: normalizeCachedDocIndex(parsed.docs),
+      outputHashes: normalizeCachedOutputHashes(parsed.outputHashes),
+    };
   } catch {
-    return { version: CACHE_VERSION, docs: {} };
+    return createEmptyCache();
   }
 }
 
@@ -252,64 +380,147 @@ function ensureUniqueRoutes(docs: DocRecord[]): void {
   }
 }
 
-async function readPublishedDocs(options: BuildOptions): Promise<DocRecord[]> {
+function normalizeWikiTarget(input: string): string {
+  return input
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/^\//, "")
+    .replace(/\.md$/i, "")
+    .toLowerCase();
+}
+
+function extractWikiTargets(markdown: string): string[] {
+  const targets = new Set<string>();
+  const re = /\[\[([^\]]+)\]\]/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = re.exec(markdown)) !== null) {
+    if (match.index > 0 && markdown.charAt(match.index - 1) === "!") {
+      continue;
+    }
+
+    const inner = (match[1] ?? "").trim();
+    if (!inner) {
+      continue;
+    }
+
+    const [rawTarget] = inner.split("|");
+    const normalized = normalizeWikiTarget(rawTarget ?? "");
+    if (!normalized) {
+      continue;
+    }
+
+    targets.add(normalized);
+  }
+
+  return Array.from(targets).sort((left, right) => left.localeCompare(right, "ko-KR"));
+}
+
+function toCachedSourceEntry(raw: string, parsed: matter.GrayMatterFile<string>): CachedSourceEntry {
+  return {
+    mtimeMs: 0,
+    size: 0,
+    rawHash: makeHash(raw),
+    publish: parsed.data.publish === true,
+    draft: parsed.data.draft === true,
+    title: typeof parsed.data.title === "string" && parsed.data.title.trim().length > 0 ? parsed.data.title.trim() : undefined,
+    date: pickDocDate(parsed.data as Record<string, unknown>, raw),
+    updatedDate: pickDocUpdatedDate(parsed.data as Record<string, unknown>, raw),
+    description: typeof parsed.data.description === "string" ? parsed.data.description.trim() || undefined : undefined,
+    tags: parseStringArray(parsed.data.tags),
+    branch: parseBranch(parsed.data.branch),
+    body: parsed.content,
+    wikiTargets: extractWikiTargets(parsed.content),
+  };
+}
+
+function toDocRecord(
+  sourcePath: string,
+  relPath: string,
+  entry: CachedSourceEntry,
+  newThreshold: number,
+): DocRecord {
+  const relNoExt = stripMdExt(relPath);
+  const fileName = path.basename(relPath);
+  const id = toDocId(relNoExt);
+
+  return {
+    sourcePath,
+    relPath,
+    relNoExt,
+    id,
+    route: toRoute(relNoExt),
+    contentUrl: `/content/${toContentFileName(id)}`,
+    fileName,
+    title: entry.title ?? makeTitleFromFileName(fileName),
+    date: entry.date,
+    updatedDate: entry.updatedDate,
+    description: entry.description,
+    tags: entry.tags,
+    mtimeMs: entry.mtimeMs,
+    body: entry.body,
+    rawHash: entry.rawHash,
+    wikiTargets: entry.wikiTargets,
+    isNew: entry.mtimeMs >= newThreshold,
+    branch: entry.branch,
+  };
+}
+
+async function readPublishedDocs(options: BuildOptions, previousSources: BuildCache["sources"]): Promise<ReadDocsResult> {
   const isExcluded = buildExcluder(options.exclude);
   const mdFiles = await walkMarkdownFiles(options.vaultDir, options.vaultDir, isExcluded);
+  const fileEntries = await Promise.all(
+    mdFiles.map(async (sourcePath) => ({
+      sourcePath,
+      relPath: relativePosix(options.vaultDir, sourcePath),
+      stat: await fs.stat(sourcePath),
+    })),
+  );
   const now = Date.now();
   const newThreshold = now - options.newWithinDays * 24 * 60 * 60 * 1000;
 
   const docs: DocRecord[] = [];
+  const nextSources: BuildCache["sources"] = {};
+
+  for (const { sourcePath, relPath, stat } of fileEntries) {
+    const prev = previousSources[relPath];
+
+    let entry: CachedSourceEntry;
+    const canReuse = !!prev && prev.mtimeMs === stat.mtimeMs && prev.size === stat.size;
+    if (canReuse) {
+      entry = prev;
+    } else {
+      const raw = await Bun.file(sourcePath).text();
+
+      let parsed: matter.GrayMatterFile<string>;
+      try {
+        parsed = matter(raw);
+      } catch (error) {
+        throw new Error(`Frontmatter parse failed: ${relPath}\n${(error as Error).message}`);
+      }
 
-  for (const sourcePath of mdFiles) {
-    const relPath = relativePosix(options.vaultDir, sourcePath);
-    const relNoExt = stripMdExt(relPath);
-    const stat = await fs.stat(sourcePath);
-    const raw = await Bun.file(sourcePath).text();
-
-    let parsed: matter.GrayMatterFile<string>;
-    try {
-      parsed = matter(raw);
-    } catch (error) {
-      throw new Error(`Frontmatter parse failed: ${relPath}\n${(error as Error).message}`);
+      entry = toCachedSourceEntry(raw, parsed);
     }
 
-    const publish = parsed.data.publish === true;
-    const draft = parsed.data.draft === true;
-    if (!publish || draft) {
+    const completeEntry: CachedSourceEntry = {
+      ...entry,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+    };
+    nextSources[relPath] = completeEntry;
+
+    if (!completeEntry.publish || completeEntry.draft) {
       continue;
     }
-
-    const fileName = path.basename(relPath);
-    const id = toDocId(relNoExt);
-    const route = toRoute(relNoExt);
-    const mtimeMs = stat.mtimeMs;
-
-    docs.push({
-      sourcePath,
-      relPath,
-      relNoExt,
-      id,
-      route,
-      contentUrl: `/content/${toContentFileName(id)}`,
-      fileName,
-      title: typeof parsed.data.title === "string" && parsed.data.title.trim().length > 0 ? parsed.data.title.trim() : makeTitleFromFileName(fileName),
-      date: pickDocDate(parsed.data as Record<string, unknown>, raw),
-      updatedDate: pickDocUpdatedDate(parsed.data as Record<string, unknown>, raw),
-      description: typeof parsed.data.description === "string" ? parsed.data.description : undefined,
-      tags: parseStringArray(parsed.data.tags),
-      mtimeMs,
-      body: parsed.content,
-      raw,
-      isNew: mtimeMs >= newThreshold,
-      branch: parseBranch(parsed.data.branch),
-    });
+    docs.push(toDocRecord(sourcePath, relPath, completeEntry, newThreshold));
   }
 
   ensureUniqueRoutes(docs);
-  return docs;
+  return { docs, nextSources };
 }
 
-function createWikiResolver(docs: DocRecord[], currentDoc: DocRecord): WikiResolver {
+function createWikiLookup(docs: DocRecord[]): WikiLookup {
   const byPath = new Map<string, DocRecord>();
   const byStem = new Map<string, DocRecord[]>();
 
@@ -321,40 +532,47 @@ function createWikiResolver(docs: DocRecord[], currentDoc: DocRecord): WikiResol
     byStem.set(stem, bucket);
   }
 
-  return {
-    resolve(input: string) {
-      const normalized = input
-        .trim()
-        .replace(/\\/g, "/")
-        .replace(/^\.\//, "")
-        .replace(/^\//, "")
-        .replace(/\.md$/i, "");
-
-      if (!normalized) {
-        return null;
-      }
+  return { byPath, byStem };
+}
 
-      const direct = byPath.get(normalized.toLowerCase());
-      if (direct) {
-        return { route: direct.route, label: direct.title };
-      }
+function resolveWikiTarget(
+  lookup: WikiLookup,
+  input: string,
+  currentDoc: DocRecord,
+  warnOnDuplicate: boolean,
+): { route: string; label: string } | null {
+  const normalized = normalizeWikiTarget(input);
+  if (!normalized) {
+    return null;
+  }
 
-      if (normalized.includes("/")) {
-        return null;
-      }
+  const direct = lookup.byPath.get(normalized);
+  if (direct) {
+    return { route: direct.route, label: direct.title };
+  }
 
-      const stemMatches = byStem.get(normalized.toLowerCase()) ?? [];
-      if (stemMatches.length === 1) {
-        return { route: stemMatches[0].route, label: stemMatches[0].title };
-      }
+  if (normalized.includes("/")) {
+    return null;
+  }
 
-      if (stemMatches.length > 1) {
-        console.warn(
-          `[wikilink] Duplicate target "${input}" in ${currentDoc.relPath}. Candidates: ${stemMatches.map((item) => item.relPath).join(", ")}`,
-        );
-      }
+  const stemMatches = lookup.byStem.get(normalized) ?? [];
+  if (stemMatches.length === 1) {
+    return { route: stemMatches[0].route, label: stemMatches[0].title };
+  }
 
-      return null;
+  if (warnOnDuplicate && stemMatches.length > 1) {
+    console.warn(
+      `[wikilink] Duplicate target "${input}" in ${currentDoc.relPath}. Candidates: ${stemMatches.map((item) => item.relPath).join(", ")}`,
+    );
+  }
+
+  return null;
+}
+
+function createWikiResolver(lookup: WikiLookup, currentDoc: DocRecord): WikiResolver {
+  return {
+    resolve(input: string) {
+      return resolveWikiTarget(lookup, input, currentDoc, true);
     },
   };
 }
@@ -599,13 +817,36 @@ function buildStructuredData(route: string, doc: DocRecord | null, options: Buil
   return [articleSchema];
 }
 
-async function writeRuntimeAssets(outDir: string): Promise<void> {
-  const assetsDir = path.join(outDir, "assets");
-  await ensureDir(assetsDir);
+function toRouteOutputPath(route: string): string {
+  const clean = route.replace(/^\/+/, "").replace(/\/+$/, "");
+  return clean ? `${clean}/index.html` : "index.html";
+}
+
+async function writeOutputIfChanged(
+  context: OutputWriteContext,
+  relOutputPath: string,
+  content: string,
+): Promise<void> {
+  const outputHash = makeHash(content);
+  context.nextHashes[relOutputPath] = outputHash;
+
+  const outputPath = path.join(context.outDir, relOutputPath);
+  const unchanged = context.previousHashes[relOutputPath] === outputHash;
+  if (unchanged) {
+    return;
+  }
+
+  await ensureDir(path.dirname(outputPath));
+  await Bun.write(outputPath, content);
+}
 
+async function writeRuntimeAssets(context: OutputWriteContext): Promise<void> {
   const runtimeDir = path.join(import.meta.dir, "runtime");
-  await fs.copyFile(path.join(runtimeDir, "app.js"), path.join(assetsDir, "app.js"));
-  await fs.copyFile(path.join(runtimeDir, "app.css"), path.join(assetsDir, "app.css"));
+  const runtimeJs = await Bun.file(path.join(runtimeDir, "app.js")).text();
+  const runtimeCss = await Bun.file(path.join(runtimeDir, "app.css")).text();
+
+  await writeOutputIfChanged(context, "assets/app.js", runtimeJs);
+  await writeOutputIfChanged(context, "assets/app.css", runtimeCss);
 }
 
 function buildShellMeta(route: string, doc: DocRecord | null, options: BuildOptions): AppShellMeta {
@@ -633,17 +874,18 @@ function buildShellMeta(route: string, doc: DocRecord | null, options: BuildOpti
   };
 }
 
-async function writeShellPages(outDir: string, docs: DocRecord[], options: BuildOptions): Promise<void> {
+async function writeShellPages(context: OutputWriteContext, docs: DocRecord[], options: BuildOptions): Promise<void> {
   const shell = renderAppShellHtml(buildShellMeta("/", null, options));
-  await ensureDir(path.join(outDir, "_app"));
-  await Bun.write(path.join(outDir, "_app", "index.html"), shell);
-  await Bun.write(path.join(outDir, "index.html"), shell);
-  await Bun.write(path.join(outDir, "404.html"), render404Html());
+  await writeOutputIfChanged(context, "_app/index.html", shell);
+  await writeOutputIfChanged(context, "index.html", shell);
+  await writeOutputIfChanged(context, "404.html", render404Html());
 
   for (const doc of docs) {
-    const routeDir = path.join(outDir, doc.route.replace(/^\/+/, "").replace(/\/+$/, ""));
-    await ensureDir(routeDir);
-    await Bun.write(path.join(routeDir, "index.html"), renderAppShellHtml(buildShellMeta(doc.route, doc, options)));
+    await writeOutputIfChanged(
+      context,
+      toRouteOutputPath(doc.route),
+      renderAppShellHtml(buildShellMeta(doc.route, doc, options)),
+    );
   }
 }
 
@@ -667,8 +909,10 @@ function buildSitemapXml(urls: string[]): string {
   ].join("\n");
 }
 
-async function writeSeoArtifacts(outDir: string, docs: DocRecord[], options: BuildOptions): Promise<void> {
+async function writeSeoArtifacts(context: OutputWriteContext, docs: DocRecord[], options: BuildOptions): Promise<void> {
   if (!options.seo) {
+    await removeFileIfExists(path.join(context.outDir, "robots.txt"));
+    await removeFileIfExists(path.join(context.outDir, "sitemap.xml"));
     console.warn('[seo] Skipping robots.txt and sitemap.xml generation. Add "seo.siteUrl" to blog.config.* to enable SEO artifacts.');
     return;
   }
@@ -685,8 +929,8 @@ async function writeSeoArtifacts(outDir: string, docs: DocRecord[], options: Bui
   const sitemapUrl = buildCanonicalUrl("/sitemap.xml", seo);
   const robotsTxt = ["User-agent: *", "Allow: /", `Sitemap: ${sitemapUrl}`, ""].join("\n");
 
-  await Bun.write(path.join(outDir, "robots.txt"), robotsTxt);
-  await Bun.write(path.join(outDir, "sitemap.xml"), buildSitemapXml(urls));
+  await writeOutputIfChanged(context, "robots.txt", robotsTxt);
+  await writeOutputIfChanged(context, "sitemap.xml", buildSitemapXml(urls));
 }
 
 async function cleanRemovedOutputs(outDir: string, oldCache: BuildCache, currentDocs: DocRecord[]): Promise<void> {
@@ -723,56 +967,89 @@ export async function cleanBuildArtifacts(outDir: string): Promise<void> {
   await fs.rm(path.dirname(cachePath), { recursive: true, force: true });
 }
 
+function buildWikiResolutionSignature(doc: DocRecord, lookup: WikiLookup): string {
+  if (doc.wikiTargets.length === 0) {
+    return "";
+  }
+
+  const segments: string[] = [];
+  for (const target of doc.wikiTargets) {
+    const resolved = resolveWikiTarget(lookup, target, doc, false);
+    segments.push(`${target}->${resolved?.route ?? "null"}`);
+  }
+  return segments.join("|");
+}
+
 export async function buildSite(options: BuildOptions): Promise<BuildResult> {
   await ensureDir(options.outDir);
   await ensureDir(path.join(options.outDir, "content"));
 
   const cachePath = toCachePath();
   const previousCache = await readCache(cachePath);
-  const docs = await readPublishedDocs(options);
+  const canReuseOutputs = await fileExists(path.join(options.outDir, "manifest.json"));
+  const previousDocs = canReuseOutputs ? previousCache.docs : {};
+  const previousOutputHashes = canReuseOutputs ? previousCache.outputHashes : {};
+  const { docs, nextSources } = await readPublishedDocs(options, previousCache.sources);
   docs.sort((a, b) => a.relNoExt.localeCompare(b.relNoExt, "ko-KR"));
 
   await cleanRemovedOutputs(options.outDir, previousCache, docs);
-  await writeRuntimeAssets(options.outDir);
+  const outputContext: OutputWriteContext = {
+    outDir: options.outDir,
+    previousHashes: previousOutputHashes,
+    nextHashes: {},
+  };
+  await writeRuntimeAssets(outputContext);
 
   const tree = buildTree(docs, options);
   const manifest = buildManifest(docs, tree, options);
-  await Bun.write(path.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+  await writeOutputIfChanged(outputContext, "manifest.json", `${JSON.stringify(manifest, null, 2)}\n`);
 
-  await writeShellPages(options.outDir, docs, options);
-  await writeSeoArtifacts(options.outDir, docs, options);
+  await writeShellPages(outputContext, docs, options);
+  await writeSeoArtifacts(outputContext, docs, options);
 
   const markdownRenderer = await createMarkdownRenderer(options);
-  const globalFingerprint = makeHash(docs.map((doc) => doc.relNoExt).sort().join("|"));
+  const wikiLookup = createWikiLookup(docs);
 
   let renderedDocs = 0;
   let skippedDocs = 0;
 
   const nextCache: BuildCache = {
     version: CACHE_VERSION,
+    sources: nextSources,
     docs: {},
+    outputHashes: outputContext.nextHashes,
   };
 
   for (const doc of docs) {
+    const wikiSignature = options.wikilinks ? buildWikiResolutionSignature(doc, wikiLookup) : "";
     const sourceHash = makeHash(
-      [doc.raw, options.shikiTheme, options.imagePolicy, options.wikilinks ? "wikilinks-on" : "wikilinks-off", globalFingerprint].join("::"),
+      [
+        doc.rawHash,
+        doc.route,
+        options.shikiTheme,
+        options.imagePolicy,
+        options.wikilinks ? "wikilinks-on" : "wikilinks-off",
+        wikiSignature,
+      ].join("::"),
     );
-    const previous = previousCache.docs[doc.id];
+    const previous = previousDocs[doc.id];
+    const contentRelPath = `content/${toContentFileName(doc.id)}`;
     const outputPath = path.join(options.outDir, "content", toContentFileName(doc.id));
-    const unchanged = previous?.hash === sourceHash && (await fileExists(outputPath));
+    const unchanged = previous?.hash === sourceHash && outputContext.previousHashes[contentRelPath] === sourceHash;
 
     nextCache.docs[doc.id] = {
       hash: sourceHash,
       route: doc.route,
       relPath: doc.relPath,
     };
+    outputContext.nextHashes[contentRelPath] = sourceHash;
 
     if (unchanged) {
       skippedDocs += 1;
       continue;
     }
 
-    const resolver = createWikiResolver(docs, doc);
+    const resolver = createWikiResolver(wikiLookup, doc);
     const renderResult = await markdownRenderer.render(doc.body, resolver);
     if (renderResult.warnings.length > 0) {
       for (const warning of renderResult.warnings) {

package/src/markdown.ts

@@ -89,8 +89,9 @@ function preprocessMarkdown(
 
 type Highlighter = HighlighterGeneric<string, string>;
 
-async function loadFenceLanguages(highlighter: Highlighter, markdown: string): Promise<void> {
+async function loadFenceLanguages(highlighter: Highlighter, loaded: Set<string>, markdown: string): Promise<void> {
   const langs = new Set<string>();
+  FENCE_LANG_RE.lastIndex = 0;
   let match: RegExpExecArray | null;
   while ((match = FENCE_LANG_RE.exec(markdown)) !== null) {
     if (match[1]) {
@@ -98,7 +99,6 @@ async function loadFenceLanguages(highlighter: Highlighter, markdown: string): P
     }
   }
 
-  const loaded = new Set(highlighter.getLoadedLanguages().map(String));
   for (const lang of langs) {
     if (loaded.has(lang)) {
       continue;
@@ -195,13 +195,14 @@ export async function createMarkdownRenderer(options: BuildOptions): Promise<Mar
     themes: [options.shikiTheme],
     langs: ["text", "plaintext", "markdown", "bash", "json", "typescript", "javascript"],
   });
+  const loadedLanguages = new Set(highlighter.getLoadedLanguages().map(String));
 
   const md = createMarkdownIt(highlighter, options.shikiTheme, options.gfm);
 
   return {
     async render(markdown: string, resolver: WikiResolver): Promise<RenderResult> {
       const { markdown: preprocessed, warnings } = preprocessMarkdown(markdown, resolver, options.imagePolicy, options.wikilinks);
-      await loadFenceLanguages(highlighter, preprocessed);
+      await loadFenceLanguages(highlighter, loadedLanguages, preprocessed);
       const html = md.render(preprocessed);
       return { html, warnings };
     },

package/src/runtime/app.js

@@ -135,14 +135,19 @@ function buildBranchView(manifest, branch, defaultBranch) {
   const visibleDocIds = new Set(docs.map((doc) => doc.id));
   const tree = cloneFilteredTree(manifest.tree, visibleDocIds);
   const routeMap = {};
+  const docIndexById = new Map();
   for (const doc of docs) {
     routeMap[doc.route] = doc.id;
   }
+  for (let i = 0; i < docs.length; i += 1) {
+    docIndexById.set(docs[i].id, i);
+  }
 
   return {
     docs,
     tree,
     routeMap,
+    docIndexById,
   };
 }
 
@@ -363,6 +368,15 @@ function initializeTreeLabelTooltip(treeRoot, tooltipEl) {
   };
 
   const show = (row) => {
+    if (!(row instanceof HTMLElement)) {
+      hide();
+      return;
+    }
+
+    if (activeRow === row && !tooltipEl.hidden) {
+      return;
+    }
+
     const labelEl = row.querySelector(".tree-label");
     if (!(labelEl instanceof HTMLElement)) {
       hide();
@@ -412,25 +426,62 @@ function initializeTreeLabelTooltip(treeRoot, tooltipEl) {
     row.setAttribute("aria-describedby", tooltipEl.id);
   };
 
-  for (const row of treeRoot.querySelectorAll(".tree-row")) {
-    if (!(row instanceof HTMLElement)) {
-      continue;
+  const getTreeRow = (target) => {
+    if (!(target instanceof Element)) {
+      return null;
+    }
+    const row = target.closest(".tree-row");
+    if (!(row instanceof HTMLElement) || !treeRoot.contains(row)) {
+      return null;
     }
-    const onMouseEnter = () => show(row);
-    const onMouseLeave = () => hide();
-    const onFocus = () => show(row);
-    const onBlur = () => hide();
+    return row;
+  };
 
-    row.addEventListener("mouseenter", onMouseEnter);
-    row.addEventListener("mouseleave", onMouseLeave);
-    row.addEventListener("focus", onFocus);
-    row.addEventListener("blur", onBlur);
+  const onMouseOver = (event) => {
+    const row = getTreeRow(event.target);
+    if (!row) {
+      return;
+    }
+    show(row);
+  };
 
-    cleanups.push(() => row.removeEventListener("mouseenter", onMouseEnter));
-    cleanups.push(() => row.removeEventListener("mouseleave", onMouseLeave));
-    cleanups.push(() => row.removeEventListener("focus", onFocus));
-    cleanups.push(() => row.removeEventListener("blur", onBlur));
-  }
+  const onMouseOut = (event) => {
+    const fromRow = getTreeRow(event.target);
+    if (!fromRow) {
+      return;
+    }
+    const toRow = getTreeRow(event.relatedTarget);
+    if (toRow === fromRow) {
+      return;
+    }
+    hide();
+  };
+
+  const onFocusIn = (event) => {
+    const row = getTreeRow(event.target);
+    if (!row) {
+      return;
+    }
+    show(row);
+  };
+
+  const onFocusOut = (event) => {
+    const toRow = getTreeRow(event.relatedTarget);
+    if (toRow) {
+      return;
+    }
+    hide();
+  };
+
+  treeRoot.addEventListener("mouseover", onMouseOver);
+  treeRoot.addEventListener("mouseout", onMouseOut);
+  treeRoot.addEventListener("focusin", onFocusIn);
+  treeRoot.addEventListener("focusout", onFocusOut);
+
+  cleanups.push(() => treeRoot.removeEventListener("mouseover", onMouseOver));
+  cleanups.push(() => treeRoot.removeEventListener("mouseout", onMouseOut));
+  cleanups.push(() => treeRoot.removeEventListener("focusin", onFocusIn));
+  cleanups.push(() => treeRoot.removeEventListener("focusout", onFocusOut));
 
   treeRoot.addEventListener("scroll", hide);
   window.addEventListener("resize", hide);
@@ -451,7 +502,7 @@ function initializeTreeLabelTooltip(treeRoot, tooltipEl) {
   };
 }
 
-function createFolderNode(node, state, depth = 0) {
+function createFolderNode(node, expandedSet, fileRowsById, depth = 0) {
   const wrapper = document.createElement("div");
   wrapper.className = node.virtual ? "tree-folder virtual" : "tree-folder";
   wrapper.style.setProperty("--tree-depth", String(depth));
@@ -459,11 +510,15 @@ function createFolderNode(node, state, depth = 0) {
   const row = document.createElement("button");
   row.type = "button";
   row.className = "tree-folder-row tree-row";
+  row.dataset.rowType = "folder";
+  row.dataset.folderPath = node.path;
+  row.dataset.virtual = String(Boolean(node.virtual));
 
-  const isExpanded = node.virtual ? true : state.expanded.has(node.path);
+  const isExpanded = node.virtual ? true : expandedSet.has(node.path);
   const iconName = isExpanded ? "folder_open" : "folder";
 
   row.innerHTML = `<span class="material-symbols-outlined">${iconName}</span><span class="tree-label">${node.name}</span>`;
+  row.setAttribute("aria-expanded", String(isExpanded));
 
   const children = document.createElement("div");
   children.className = "tree-children";
@@ -471,25 +526,11 @@ function createFolderNode(node, state, depth = 0) {
     children.hidden = true;
   }
 
-  if (!node.virtual) {
-    row.addEventListener("click", () => {
-      const currentlyExpanded = !children.hidden;
-      children.hidden = currentlyExpanded;
-      row.querySelector(".material-symbols-outlined").textContent = currentlyExpanded ? "folder" : "folder_open";
-      if (currentlyExpanded) {
-        state.expanded.delete(node.path);
-      } else {
-        state.expanded.add(node.path);
-      }
-      persistExpandedSet(state.expanded);
-    });
-  }
-
   for (const child of node.children) {
     if (child.type === "folder") {
-      children.appendChild(createFolderNode(child, state, depth + 1));
+      children.appendChild(createFolderNode(child, expandedSet, fileRowsById, depth + 1));
     } else {
-      children.appendChild(createFileNode(child, state, depth + 1));
+      children.appendChild(createFileNode(child, fileRowsById, depth + 1));
     }
   }
 
@@ -498,46 +539,65 @@ function createFolderNode(node, state, depth = 0) {
   return wrapper;
 }
 
-function createFileNode(node, state, depth = 0) {
+function createFileNode(node, fileRowsById, depth = 0) {
   const row = document.createElement("a");
   row.href = node.route;
   row.className = "tree-row tree-file-row";
+  row.dataset.rowType = "file";
+  row.dataset.route = node.route;
   row.dataset.fileId = node.id;
   row.style.setProperty("--tree-depth", String(depth));
 
   const newBadge = node.isNew ? `<span class="badge-new">NEW</span>` : "";
   row.innerHTML = `<span class="material-symbols-outlined">article</span><span class="tree-label">${node.title || node.name}</span>${newBadge}`;
-
-  row.addEventListener("click", (event) => {
-    event.preventDefault();
-    state.navigate(node.route, true);
-  });
+  fileRowsById.set(node.id, row);
 
   return row;
 }
 
-function markActive(id) {
-  for (const el of document.querySelectorAll("[data-file-id]")) {
-    if (!(el instanceof HTMLElement)) {
-      continue;
-    }
-    const badge = el.querySelector(".badge-active");
-    if (badge) {
-      badge.remove();
-    }
-    
-    if (el.dataset.fileId === id) {
-      el.classList.add("is-active");
-      el.setAttribute("aria-current", "page");
-      const activeBadge = document.createElement("span");
-      activeBadge.className = "badge-active";
-      activeBadge.textContent = "active";
-      el.appendChild(activeBadge);
-    } else {
-      el.classList.remove("is-active");
-      el.removeAttribute("aria-current");
-    }
+function setFileRowActive(row, active) {
+  if (!(row instanceof HTMLElement)) {
+    return;
+  }
+
+  const badge = row.querySelector(".badge-active");
+  if (badge) {
+    badge.remove();
   }
+
+  if (active) {
+    row.classList.add("is-active");
+    row.setAttribute("aria-current", "page");
+    const activeBadge = document.createElement("span");
+    activeBadge.className = "badge-active";
+    activeBadge.textContent = "active";
+    row.appendChild(activeBadge);
+    return;
+  }
+
+  row.classList.remove("is-active");
+  row.removeAttribute("aria-current");
+}
+
+function markActive(fileRowsById, activeState, id) {
+  if (activeState.currentId === id) {
+    return;
+  }
+
+  if (activeState.current instanceof HTMLElement) {
+    setFileRowActive(activeState.current, false);
+  }
+
+  const next = id ? fileRowsById.get(id) : null;
+  if (next instanceof HTMLElement) {
+    setFileRowActive(next, true);
+    activeState.current = next;
+    activeState.currentId = id;
+    return;
+  }
+
+  activeState.current = null;
+  activeState.currentId = "";
 }
 
 function renderBreadcrumb(route) {
@@ -581,8 +641,8 @@ function renderMeta(doc) {
   return items.join("");
 }
 
-function renderNav(docs, currentId) {
-  const currentIndex = docs.findIndex(d => d.id === currentId);
+function renderNav(docs, docIndexById, currentId) {
+  const currentIndex = docIndexById.get(currentId) ?? -1;
   if (currentIndex === -1) return "";
 
   const prev = currentIndex > 0 ? docs[currentIndex - 1] : null;
@@ -629,6 +689,7 @@ async function start() {
   const contentEl = document.getElementById("viewer-content");
   const navEl = document.getElementById("viewer-nav");
   const a11yStatusEl = document.getElementById("a11y-status");
+  const viewerEl = document.querySelector(".viewer");
 
   let hideTreeTooltip = () => {};
   let disposeTreeTooltip = () => {};
@@ -636,6 +697,11 @@ async function start() {
   let activeResizePointerId = null;
   let resizeStartX = 0;
   let resizeStartWidth = desktopSidebarWidth;
+  let treeFileRowsById = new Map();
+  const activeFileState = {
+    current: null,
+    currentId: "",
+  };
 
   const announceA11yStatus = (message) => {
     if (!(a11yStatusEl instanceof HTMLElement)) {
@@ -1029,7 +1095,17 @@ async function start() {
 
   const savedBranch = normalizeBranch(localStorage.getItem(BRANCH_KEY));
   let activeBranch = savedBranch && availableBranchSet.has(savedBranch) ? savedBranch : defaultBranch;
-  let view = buildBranchView(manifest, activeBranch, defaultBranch);
+  const branchViewCache = new Map();
+  const getBranchView = (branch) => {
+    const cached = branchViewCache.get(branch);
+    if (cached) {
+      return cached;
+    }
+    const nextView = buildBranchView(manifest, branch, defaultBranch);
+    branchViewCache.set(branch, nextView);
+    return nextView;
+  };
+  let view = getBranchView(activeBranch);
 
   const docsById = new Map(manifest.docs.map((doc) => [doc.id, doc]));
   const expanded = loadExpandedSet();
@@ -1061,19 +1137,20 @@ async function start() {
     hideTreeTooltip();
     disposeTreeTooltip();
     treeRoot.innerHTML = "";
+    treeFileRowsById = new Map();
 
     for (const node of view.tree) {
       if (node.type === "folder") {
-        treeRoot.appendChild(createFolderNode(node, state));
+        treeRoot.appendChild(createFolderNode(node, state.expanded, treeFileRowsById));
       } else {
-        treeRoot.appendChild(createFileNode(node, state));
+        treeRoot.appendChild(createFileNode(node, treeFileRowsById));
       }
     }
 
     const tooltipController = initializeTreeLabelTooltip(treeRoot, treeLabelTooltip);
     hideTreeTooltip = tooltipController.hide;
     disposeTreeTooltip = tooltipController.dispose;
-    markActive(state.currentDocId || "");
+    markActive(treeFileRowsById, activeFileState, state.currentDocId || "");
   };
 
   const state = {
@@ -1095,7 +1172,7 @@ async function start() {
         const globalDocBranch = normalizeBranch(globalDoc?.branch);
         if (globalDoc && globalDocBranch && globalDocBranch !== activeBranch && availableBranchSet.has(globalDocBranch)) {
           activeBranch = globalDocBranch;
-          view = buildBranchView(manifest, activeBranch, defaultBranch);
+          view = getBranchView(activeBranch);
           updateBranchInfo();
           renderTree(state);
           localStorage.setItem(BRANCH_KEY, activeBranch);
@@ -1110,7 +1187,7 @@ async function start() {
         metaEl.innerHTML = "";
         contentEl.innerHTML = '<p class="placeholder">요청한 경로에 해당하는 문서가 없습니다.</p>';
         navEl.innerHTML = "";
-        markActive("");
+        markActive(treeFileRowsById, activeFileState, "");
         announceA11yStatus("탐색 실패: 요청한 문서를 찾을 수 없습니다.");
         if (push) {
           history.pushState(null, "", toSafeUrlPath(route));
@@ -1128,7 +1205,7 @@ async function start() {
       }
 
       state.currentDocId = id;
-      markActive(id);
+      markActive(treeFileRowsById, activeFileState, id);
       breadcrumbEl.innerHTML = renderBreadcrumb(route);
       titleEl.textContent = doc.title;
       metaEl.innerHTML = renderMeta(doc);
@@ -1142,41 +1219,132 @@ async function start() {
       }
 
       contentEl.innerHTML = await res.text();
-      
-      for (const btn of contentEl.querySelectorAll(".code-copy")) {
-        btn.addEventListener("click", async () => {
-          const code = btn.dataset.code;
-          if (!code) return;
-          try {
-            await navigator.clipboard.writeText(code);
-            btn.classList.add("copied");
-            btn.querySelector(".material-symbols-outlined").textContent = "check";
-            setTimeout(() => {
-              btn.classList.remove("copied");
-              btn.querySelector(".material-symbols-outlined").textContent = "content_copy";
-            }, 2000);
-          } catch (err) {
-            console.error("Copy failed:", err);
-          }
-        });
-      }
 
-      navEl.innerHTML = renderNav(view.docs, id);
-      
-      for (const link of navEl.querySelectorAll(".nav-link")) {
-        link.addEventListener("click", (e) => {
-          e.preventDefault();
-          state.navigate(link.dataset.route, true);
-          document.querySelector(".viewer").scrollTo(0, 0);
-        });
-      }
+      navEl.innerHTML = renderNav(view.docs, view.docIndexById, id);
 
       document.title = `${doc.title} - File-System Blog`;
-      document.querySelector(".viewer").scrollTo(0, 0);
+      if (viewerEl instanceof HTMLElement) {
+        viewerEl.scrollTo(0, 0);
+      }
       announceA11yStatus(`탐색 완료: ${doc.title} 문서를 열었습니다.`);
     },
   };
 
+  if (treeRoot instanceof HTMLElement) {
+    treeRoot.addEventListener("click", (event) => {
+      const target = event.target;
+      if (!(target instanceof Element)) {
+        return;
+      }
+
+      const row = target.closest(".tree-row");
+      if (!(row instanceof HTMLElement) || !treeRoot.contains(row)) {
+        return;
+      }
+
+      if (row.dataset.rowType === "folder") {
+        if (row.dataset.virtual === "true") {
+          return;
+        }
+
+        const children = row.nextElementSibling;
+        if (!(children instanceof HTMLElement) || !children.classList.contains("tree-children")) {
+          return;
+        }
+
+        const currentlyExpanded = !children.hidden;
+        children.hidden = currentlyExpanded;
+        row.setAttribute("aria-expanded", String(!currentlyExpanded));
+        const icon = row.querySelector(".material-symbols-outlined");
+        if (icon instanceof HTMLElement) {
+          icon.textContent = currentlyExpanded ? "folder" : "folder_open";
+        }
+
+        const folderPath = row.dataset.folderPath;
+        if (!folderPath) {
+          return;
+        }
+        if (currentlyExpanded) {
+          state.expanded.delete(folderPath);
+        } else {
+          state.expanded.add(folderPath);
+        }
+        persistExpandedSet(state.expanded);
+        return;
+      }
+
+      if (row.dataset.rowType === "file") {
+        event.preventDefault();
+        const route = row.dataset.route;
+        if (!route) {
+          return;
+        }
+        state.navigate(route, true);
+      }
+    });
+  }
+
+  if (contentEl instanceof HTMLElement) {
+    contentEl.addEventListener("click", async (event) => {
+      const target = event.target;
+      if (!(target instanceof Element)) {
+        return;
+      }
+
+      const button = target.closest(".code-copy");
+      if (!(button instanceof HTMLButtonElement) || !contentEl.contains(button)) {
+        return;
+      }
+
+      const code = button.dataset.code;
+      if (!code) {
+        return;
+      }
+
+      try {
+        await navigator.clipboard.writeText(code);
+        button.classList.add("copied");
+        const icon = button.querySelector(".material-symbols-outlined");
+        if (icon instanceof HTMLElement) {
+          icon.textContent = "check";
+        }
+        setTimeout(() => {
+          button.classList.remove("copied");
+          const nextIcon = button.querySelector(".material-symbols-outlined");
+          if (nextIcon instanceof HTMLElement) {
+            nextIcon.textContent = "content_copy";
+          }
+        }, 2000);
+      } catch (err) {
+        console.error("Copy failed:", err);
+      }
+    });
+  }
+
+  if (navEl instanceof HTMLElement) {
+    navEl.addEventListener("click", (event) => {
+      const target = event.target;
+      if (!(target instanceof Element)) {
+        return;
+      }
+
+      const link = target.closest(".nav-link");
+      if (!(link instanceof HTMLAnchorElement) || !navEl.contains(link)) {
+        return;
+      }
+
+      event.preventDefault();
+      const route = link.dataset.route;
+      if (!route) {
+        return;
+      }
+      state.navigate(route, true);
+      if (viewerEl instanceof HTMLElement) {
+        viewerEl.scrollTo(0, 0);
+      }
+    });
+  }
+
   initializeTreeTypeahead(treeRoot);
 
   const setActiveBranch = async (nextBranch) => {
@@ -1186,7 +1354,7 @@ async function start() {
     }
 
     activeBranch = normalized;
-    view = buildBranchView(manifest, activeBranch, defaultBranch);
+    view = getBranchView(activeBranch);
     localStorage.setItem(BRANCH_KEY, activeBranch);
     updateBranchInfo();
     renderTree(state);

package/src/types.ts

@@ -64,7 +64,8 @@ export interface DocRecord {
   tags: string[];
   mtimeMs: number;
   body: string;
-  raw: string;
+  rawHash: string;
+  wikiTargets: string[];
   isNew: boolean;
   branch: string | null;
 }
@@ -122,6 +123,24 @@ export interface Manifest {
 
 export interface BuildCache {
   version: number;
+  sources: Record<
+    string,
+    {
+      mtimeMs: number;
+      size: number;
+      rawHash: string;
+      publish: boolean;
+      draft: boolean;
+      title?: string;
+      date?: string;
+      updatedDate?: string;
+      description?: string;
+      tags: string[];
+      branch: string | null;
+      body: string;
+      wikiTargets: string[];
+    }
+  >;
   docs: Record<
     string,
     {
@@ -130,6 +149,7 @@ export interface BuildCache {
       relPath: string;
     }
   >;
+  outputHashes: Record<string, string>;
 }
 
 export interface WikiResolver {