folderblog 0.0.1 → 0.0.3

package/dist/chunk-LPPBVXJ7.js

@@ -0,0 +1,1786 @@
+import { OUTPUT_FILES } from './chunk-D26H5722.js';
+import { PluginManager } from './chunk-B43UAOPC.js';
+import { __require } from './chunk-3RG5ZIWI.js';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkRehype from 'remark-rehype';
+import rehypeStringify from 'rehype-stringify';
+import rehypeRaw from 'rehype-raw';
+import rehypeSlug from 'rehype-slug';
+import GithubSlugger from 'github-slugger';
+import matter from 'gray-matter';
+import crypto from 'crypto';
+import slugify from '@sindresorhus/slugify';
+import fs from 'fs/promises';
+import path5 from 'path';
+import { visit } from 'unist-util-visit';
+
+// ../processor/src/services/issueCollector.ts
+var IssueCollector = class {
+  issues = [];
+  startTime;
+  constructor() {
+    this.startTime = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  // --------------------------------------------------------------------------
+  // Core Methods
+  // --------------------------------------------------------------------------
+  /**
+   * Add a generic issue
+   */
+  addIssue(issue) {
+    this.issues.push({
+      ...issue,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Add a broken link issue
+   */
+  addBrokenLink(params) {
+    this.addIssue({
+      severity: "warning",
+      category: "broken-link",
+      module: "link-resolver",
+      message: `Broken ${params.linkType} link: [[${params.linkTarget}]] - target not found`,
+      filePath: params.filePath,
+      lineNumber: params.lineNumber,
+      context: {
+        linkText: params.linkText,
+        linkTarget: params.linkTarget,
+        linkType: params.linkType,
+        suggestions: params.suggestions
+      }
+    });
+  }
+  /**
+   * Add a missing media issue
+   */
+  addMissingMedia(params) {
+    this.addIssue({
+      severity: "warning",
+      category: "missing-media",
+      module: params.module ?? "embed-media",
+      message: `Missing media file: ${params.mediaPath}`,
+      filePath: params.filePath,
+      lineNumber: params.lineNumber,
+      context: {
+        mediaPath: params.mediaPath,
+        referencedFrom: params.referencedFrom,
+        originalReference: params.originalReference
+      }
+    });
+  }
+  /**
+   * Add a media processing error
+   */
+  addMediaProcessingError(params) {
+    this.addIssue({
+      severity: "error",
+      category: "media-processing",
+      module: "image-processor",
+      message: `Failed to ${params.operation} media: ${params.mediaPath} - ${params.errorMessage}`,
+      filePath: params.filePath,
+      context: {
+        mediaPath: params.mediaPath,
+        operation: params.operation,
+        errorMessage: params.errorMessage,
+        errorCode: params.errorCode
+      }
+    });
+  }
+  /**
+   * Add a slug conflict warning
+   */
+  addSlugConflict(params) {
+    this.addIssue({
+      severity: "info",
+      category: "slug-conflict",
+      module: "slug-generator",
+      message: `Slug conflict resolved: "${params.originalSlug}" \u2192 "${params.finalSlug}"`,
+      filePath: params.filePath,
+      context: {
+        originalSlug: params.originalSlug,
+        finalSlug: params.finalSlug,
+        conflictingFiles: params.conflictingFiles
+      }
+    });
+  }
+  /**
+   * Add a mermaid error
+   */
+  addMermaidError(params) {
+    this.addIssue({
+      severity: params.errorType === "missing-deps" ? "info" : "warning",
+      category: "mermaid-error",
+      module: "embed-mermaid",
+      message: params.message,
+      filePath: params.filePath,
+      lineNumber: params.lineNumber,
+      context: {
+        errorType: params.errorType,
+        diagramContent: params.diagramContent,
+        fallback: params.fallback
+      }
+    });
+  }
+  /**
+   * Add an embedding error
+   */
+  addEmbeddingError(params) {
+    this.addIssue({
+      severity: "error",
+      category: "embedding-error",
+      module: params.embeddingType === "text" ? "text-embeddings" : "image-embeddings",
+      message: `${params.embeddingType} embedding ${params.operation} failed: ${params.errorMessage}`,
+      filePath: params.filePath,
+      context: {
+        embeddingType: params.embeddingType,
+        operation: params.operation,
+        errorMessage: params.errorMessage
+      }
+    });
+  }
+  /**
+   * Add a plugin error
+   */
+  addPluginError(params) {
+    this.addIssue({
+      severity: "error",
+      category: "plugin-error",
+      module: "plugin-manager",
+      message: `Plugin "${params.pluginName}" ${params.operation} failed: ${params.errorMessage}`,
+      context: {
+        pluginName: params.pluginName,
+        operation: params.operation,
+        errorMessage: params.errorMessage
+      }
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Query Methods
+  // --------------------------------------------------------------------------
+  /**
+   * Get all issues
+   */
+  getIssues() {
+    return [...this.issues];
+  }
+  /**
+   * Filter issues
+   */
+  filterIssues(options) {
+    return filterIssues(this.issues, options);
+  }
+  /**
+   * Get issue count by severity
+   */
+  getCountBySeverity(severity) {
+    return this.issues.filter((i) => i.severity === severity).length;
+  }
+  /**
+   * Check if there are any errors
+   */
+  hasErrors() {
+    return this.getCountBySeverity("error") > 0;
+  }
+  /**
+   * Get summary string for console output
+   */
+  getSummaryString() {
+    const errors = this.getCountBySeverity("error");
+    const warnings = this.getCountBySeverity("warning");
+    const info = this.getCountBySeverity("info");
+    const parts = [];
+    if (errors > 0) parts.push(`${errors} error${errors > 1 ? "s" : ""}`);
+    if (warnings > 0) parts.push(`${warnings} warning${warnings > 1 ? "s" : ""}`);
+    if (info > 0) parts.push(`${info} info`);
+    return parts.length > 0 ? `Processing completed with ${parts.join(", ")}` : "Processing completed successfully";
+  }
+  // --------------------------------------------------------------------------
+  // Report Generation
+  // --------------------------------------------------------------------------
+  /**
+   * Generate the final report
+   */
+  generateReport() {
+    const endTime = (/* @__PURE__ */ new Date()).toISOString();
+    return generateIssueReport(this.issues, this.startTime, endTime);
+  }
+  /**
+   * Clear all issues (for testing)
+   */
+  clear() {
+    this.issues = [];
+  }
+};
+var filterIssues = (issues, options) => {
+  let filtered = [...issues];
+  if (options.severity) {
+    const severities = Array.isArray(options.severity) ? options.severity : [options.severity];
+    filtered = filtered.filter((i) => severities.includes(i.severity));
+  }
+  if (options.category) {
+    const categories = Array.isArray(options.category) ? options.category : [options.category];
+    filtered = filtered.filter((i) => categories.includes(i.category));
+  }
+  if (options.module) {
+    const modules = Array.isArray(options.module) ? options.module : [options.module];
+    filtered = filtered.filter((i) => modules.includes(i.module));
+  }
+  if (options.filePath) {
+    const paths = Array.isArray(options.filePath) ? options.filePath : [options.filePath];
+    filtered = filtered.filter((i) => i.filePath && paths.includes(i.filePath));
+  }
+  return filtered;
+};
+var calculateSummary = (issues) => {
+  const errorCount = issues.filter((i) => i.severity === "error").length;
+  const warningCount = issues.filter((i) => i.severity === "warning").length;
+  const infoCount = issues.filter((i) => i.severity === "info").length;
+  const uniqueFiles = new Set(issues.map((i) => i.filePath).filter(Boolean));
+  const categoryCounts = {};
+  const moduleCounts = {};
+  for (const issue of issues) {
+    categoryCounts[issue.category] = (categoryCounts[issue.category] ?? 0) + 1;
+    moduleCounts[issue.module] = (moduleCounts[issue.module] ?? 0) + 1;
+  }
+  return {
+    totalIssues: issues.length,
+    errorCount,
+    warningCount,
+    infoCount,
+    filesAffected: uniqueFiles.size,
+    categoryCounts,
+    moduleCounts
+  };
+};
+var generateIssueReport = (issues, startTime, endTime) => ({
+  issues,
+  summary: calculateSummary(issues),
+  metadata: {
+    processStartTime: startTime,
+    processEndTime: endTime
+  }
+});
+var parseFrontmatter = (content) => {
+  const { content: markdown, data } = matter(content);
+  return {
+    content: markdown,
+    data
+  };
+};
+var DEFAULT_PIPELINE_OPTIONS = {
+  gfm: true,
+  allowRawHtml: true,
+  remarkPlugins: [],
+  rehypePlugins: []
+};
+var createBasePipeline = (options = {}) => {
+  const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
+  let processor = unified().use(remarkParse);
+  if (opts.gfm) {
+    processor = processor.use(remarkGfm);
+  }
+  for (const { plugin, options: pluginOpts } of opts.remarkPlugins ?? []) {
+    processor = processor.use(plugin, pluginOpts);
+  }
+  processor = processor.use(remarkRehype, {
+    allowDangerousHtml: opts.allowRawHtml
+  });
+  if (opts.allowRawHtml) {
+    processor = processor.use(rehypeRaw);
+  }
+  processor = processor.use(rehypeSlug);
+  for (const { plugin, options: pluginOpts } of opts.rehypePlugins ?? []) {
+    processor = processor.use(plugin, pluginOpts);
+  }
+  processor = processor.use(rehypeStringify);
+  return processor;
+};
+var parseToMdast = (markdown) => {
+  const processor = unified().use(remarkParse).use(remarkGfm);
+  return processor.parse(markdown);
+};
+var mdastToHast = async (mdast, options = {}) => {
+  const processor = unified().use(remarkRehype, { allowDangerousHtml: options.allowDangerousHtml ?? true }).use(rehypeRaw).use(rehypeSlug);
+  const result = await processor.run(mdast);
+  return result;
+};
+var hastToHtml = (hast) => {
+  const processor = unified().use(rehypeStringify);
+  return processor.stringify(hast);
+};
+var processMarkdown = async (content, options = {}) => {
+  const { content: markdown, data: frontmatter } = parseFrontmatter(content);
+  const mdast = parseToMdast(markdown);
+  const pipeline = createBasePipeline(options);
+  const file = await pipeline.process(markdown);
+  const hast = await mdastToHast(mdast, {
+    allowDangerousHtml: options.allowRawHtml ?? true
+  });
+  return {
+    html: String(file),
+    markdown,
+    frontmatter,
+    mdast,
+    hast
+  };
+};
+var mdastToText = (node) => {
+  const parts = [];
+  const visit2 = (n) => {
+    if (n.type === "text" || n.type === "inlineCode") {
+      parts.push(n.value);
+    }
+    if (n.children) {
+      for (const child of n.children) {
+        visit2(child);
+      }
+    }
+  };
+  visit2(node);
+  return parts.join(" ");
+};
+var extractFirstParagraph = (mdast) => {
+  for (const node of mdast.children) {
+    if (node.type === "paragraph") {
+      return mdastToText({ type: "root", children: [node] });
+    }
+  }
+  return "";
+};
+var extractHeadings = (mdast) => {
+  const headings = [];
+  const visit2 = (node) => {
+    if (node.type === "heading") {
+      headings.push({
+        depth: node.depth,
+        text: mdastToText({ type: "root", children: node.children })
+      });
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        visit2(child);
+      }
+    }
+  };
+  visit2(mdast);
+  return headings;
+};
+var buildToc = (headings) => {
+  const slugger = new GithubSlugger();
+  return headings.map((h) => ({
+    ...h,
+    slug: slugger.slug(h.text)
+  }));
+};
+
+// ../processor/src/markdown/wordCount.ts
+var countWords = (text) => {
+  if (!text || typeof text !== "string") {
+    return 0;
+  }
+  const normalized = text.trim().replace(/\s+/g, " ");
+  if (normalized.length === 0) {
+    return 0;
+  }
+  const words = normalized.split(" ").filter((word) => word.length > 0);
+  return words.length;
+};
+var estimateReadingTime = (wordCount, wordsPerMinute = 200) => {
+  return Math.max(1, Math.ceil(wordCount / wordsPerMinute));
+};
+var getContentStats = (text) => {
+  const wordCount = countWords(text);
+  return {
+    wordCount,
+    readingTimeMinutes: estimateReadingTime(wordCount)
+  };
+};
+var hashContent = (content) => {
+  const hashSum = crypto.createHash("sha256");
+  hashSum.update(content);
+  return hashSum.digest("hex");
+};
+var hashBuffer = (buffer) => {
+  const hashSum = crypto.createHash("sha256");
+  hashSum.update(new Uint8Array(buffer));
+  return hashSum.digest("hex");
+};
+var shortHash = (content, length = 8) => hashContent(content).substring(0, length);
+var combineHashes = (...values) => hashContent(values.join(":"));
+var toSlug = (s) => slugify(s, { decamelize: false });
+var generateBaseSlug = (options) => {
+  const { fileName, parentFolder, siblingCount, frontmatterSlug } = options;
+  if (frontmatterSlug) {
+    return {
+      slug: frontmatterSlug,
+      source: "frontmatter"
+    };
+  }
+  if (fileName === "index" && parentFolder && (siblingCount === void 0 || siblingCount === 1)) {
+    return {
+      slug: toSlug(parentFolder),
+      source: "folder"
+    };
+  }
+  return {
+    slug: toSlug(fileName),
+    source: "filename"
+  };
+};
+var resolveSlugConflict = (baseSlug, usedSlugs, strategy = "number") => {
+  if (!usedSlugs.has(baseSlug)) {
+    return baseSlug;
+  }
+  if (strategy === "number") {
+    let counter = 2;
+    let newSlug = `${baseSlug}${counter}`;
+    while (usedSlugs.has(newSlug)) {
+      counter++;
+      newSlug = `${baseSlug}${counter}`;
+    }
+    return newSlug;
+  }
+  const hash = __require("crypto").createHash("sha256").update(baseSlug + Date.now().toString()).digest("hex").substring(0, 6);
+  return `${baseSlug}-${hash}`;
+};
+var SlugManager = class {
+  usedSlugs = /* @__PURE__ */ new Map();
+  scopedSlugs = /* @__PURE__ */ new Map();
+  fileSlugs = /* @__PURE__ */ new Map();
+  strategy;
+  constructor(strategy = "number") {
+    this.strategy = strategy;
+  }
+  /**
+   * Check if a slug is already used
+   */
+  isUsed(slug) {
+    return this.usedSlugs.has(slug);
+  }
+  /**
+   * Get slug info for a file path
+   */
+  getSlugInfo(filePath) {
+    return this.fileSlugs.get(filePath);
+  }
+  /**
+   * Get the slug map for a given scope, creating it if needed
+   */
+  getScopeMap(scope) {
+    let map = this.scopedSlugs.get(scope);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.scopedSlugs.set(scope, map);
+    }
+    return map;
+  }
+  /**
+   * Reserve a slug for a file
+   * @param scope - Optional scope for slug deduplication (e.g. top-level folder)
+   */
+  reserve(filePath, options, scope) {
+    const { slug: baseSlug, source } = generateBaseSlug(options);
+    const slugMap = scope !== void 0 ? this.getScopeMap(scope) : this.usedSlugs;
+    const existingFile = slugMap.get(baseSlug);
+    const wasModified = existingFile !== void 0 && existingFile !== filePath;
+    const finalSlug = wasModified ? resolveSlugConflict(baseSlug, new Set(slugMap.keys()), this.strategy) : baseSlug;
+    const info = {
+      slug: finalSlug,
+      originalSlug: baseSlug,
+      source,
+      wasModified
+    };
+    slugMap.set(finalSlug, filePath);
+    this.fileSlugs.set(filePath, info);
+    return info;
+  }
+  /**
+   * Get all assigned slugs
+   */
+  getAllSlugs() {
+    return this.fileSlugs;
+  }
+};
+var getFileName = (filePath) => {
+  const { name } = path5.parse(filePath);
+  return name;
+};
+var getExtension = (filePath) => {
+  const { ext } = path5.parse(filePath);
+  return ext.slice(1).toLowerCase();
+};
+var fileExists = async (filePath) => {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var ensureDir = async (dirPath) => {
+  await fs.mkdir(dirPath, { recursive: true });
+};
+var writeJson = async (filePath, data) => {
+  await ensureDir(path5.dirname(filePath));
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+};
+var readJson = async (filePath) => {
+  const content = await fs.readFile(filePath, "utf8");
+  return JSON.parse(content);
+};
+var writeText = async (filePath, content) => {
+  await ensureDir(path5.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf8");
+};
+var readText = async (filePath) => {
+  return fs.readFile(filePath, "utf8");
+};
+var copyFile = async (src, dest) => {
+  await ensureDir(path5.dirname(dest));
+  await fs.copyFile(src, dest);
+};
+var getStats = async (filePath) => {
+  const stats = await fs.stat(filePath);
+  return {
+    size: stats.size,
+    created: stats.birthtime,
+    modified: stats.mtime
+  };
+};
+var findFiles = async (dir, predicate, recursive = true) => {
+  const results = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory() && recursive) {
+      const nested = await findFiles(fullPath, predicate, recursive);
+      results.push(...nested);
+    } else if (entry.isFile() && predicate(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+};
+var findMarkdownFiles = (dir, recursive = true) => findFiles(dir, (name) => name.endsWith(".md"), recursive);
+var relativePath = (from, to) => path5.relative(from, to);
+var normalizePath = (p) => p.split(path5.sep).join("/");
+function findByFileNameCaseInsensitive(fileName, fileMap) {
+  const exact = fileMap.get(fileName);
+  if (exact) return exact;
+  const lowerFileName = fileName.toLowerCase();
+  for (const [key, value] of fileMap.entries()) {
+    if (key.toLowerCase() === lowerFileName) {
+      return value;
+    }
+  }
+  return [];
+}
+function resolveFromCandidates(candidates, currentFilePath) {
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  if (!candidates.length) {
+    return null;
+  }
+  if (currentFilePath) {
+    const currentDir = path5.dirname(currentFilePath);
+    const sameDir = candidates.find(
+      (f) => path5.dirname(f.originalPath) === currentDir
+    );
+    if (sameDir) return sameDir;
+    let parentDir = currentDir;
+    while (parentDir && parentDir !== "." && parentDir !== "/") {
+      parentDir = path5.dirname(parentDir);
+      const parentMatch = candidates.find(
+        (f) => path5.dirname(f.originalPath) === parentDir
+      );
+      if (parentMatch) return parentMatch;
+    }
+  }
+  return candidates[0];
+}
+function createPathVariations(targetPath, currentFilePath) {
+  const normalizedPath = targetPath.replace(/\\/g, "/");
+  const withLeadingSlash = normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`;
+  const withoutLeadingSlash = normalizedPath.startsWith("/") ? normalizedPath.substring(1) : normalizedPath;
+  const variations = [
+    normalizedPath,
+    normalizedPath.toLowerCase(),
+    withLeadingSlash,
+    withLeadingSlash.toLowerCase(),
+    withoutLeadingSlash,
+    withoutLeadingSlash.toLowerCase()
+  ];
+  if (currentFilePath && (normalizedPath.includes("../") || normalizedPath.includes("./"))) {
+    const currentDir = path5.dirname(currentFilePath);
+    const resolvedPath = path5.join(currentDir, normalizedPath).replace(/\\/g, "/");
+    const normalizedResolved = path5.normalize(resolvedPath).replace(/\\/g, "/");
+    variations.unshift(normalizedResolved, normalizedResolved.toLowerCase());
+  }
+  if (currentFilePath && !normalizedPath.includes("/")) {
+    const currentDir = path5.dirname(currentFilePath);
+    if (currentDir && currentDir !== ".") {
+      const inCurrentDir = path5.join(currentDir, normalizedPath).replace(/\\/g, "/");
+      variations.unshift(inCurrentDir, inCurrentDir.toLowerCase());
+    }
+  }
+  const baseName = path5.basename(normalizedPath);
+  if (baseName !== normalizedPath) {
+    variations.push(baseName, baseName.toLowerCase());
+  }
+  return [...new Set(variations)];
+}
+function resolveFile(targetPath, options) {
+  const { byPath, byName, currentFilePath, extensions = [] } = options;
+  const baseVariations = createPathVariations(targetPath, currentFilePath);
+  const allVariations = [];
+  for (const variation of baseVariations) {
+    allVariations.push(variation);
+    const hasExtension = extensions.some((ext) => variation.endsWith(ext));
+    if (!hasExtension) {
+      for (const ext of extensions) {
+        allVariations.push(variation + ext);
+      }
+    }
+  }
+  for (const variation of allVariations) {
+    const exactMatch = byPath.get(variation);
+    if (exactMatch) return exactMatch;
+  }
+  if (byName) {
+    const fileName = path5.basename(targetPath);
+    const candidates = findByFileNameCaseInsensitive(fileName, byName);
+    if (candidates.length > 0) {
+      return resolveFromCandidates(candidates, currentFilePath);
+    }
+    for (const ext of extensions) {
+      if (fileName.endsWith(ext)) {
+        const nameWithoutExt = fileName.slice(0, -ext.length);
+        const candidatesNoExt = findByFileNameCaseInsensitive(
+          nameWithoutExt,
+          byName
+        );
+        if (candidatesNoExt.length > 0) {
+          return resolveFromCandidates(candidatesNoExt, currentFilePath);
+        }
+      }
+    }
+  }
+  return null;
+}
+function buildFileMaps(posts) {
+  const byPath = /* @__PURE__ */ new Map();
+  const bySlug = /* @__PURE__ */ new Map();
+  const byFileName = /* @__PURE__ */ new Map();
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const post of posts) {
+    byPath.set(post.originalPath, post);
+    bySlug.set(post.slug, post);
+    const fileName = path5.basename(post.originalPath, ".md");
+    if (!byFileName.has(fileName)) {
+      byFileName.set(fileName, []);
+    }
+    byFileName.get(fileName).push(post);
+    const aliases = post.frontmatter?.aliases;
+    if (Array.isArray(aliases)) {
+      for (const alias of aliases) {
+        if (typeof alias === "string" && alias.trim()) {
+          const normalizedAlias = alias.trim().toLowerCase();
+          if (!byAlias.has(normalizedAlias)) {
+            byAlias.set(normalizedAlias, []);
+          }
+          byAlias.get(normalizedAlias).push(post);
+        }
+      }
+    }
+  }
+  return { byPath, bySlug, byFileName, byAlias };
+}
+function findBySlugCaseInsensitive(slug, bySlug) {
+  const exact = bySlug.get(slug);
+  if (exact) return exact;
+  const lowerSlug = slug.toLowerCase();
+  for (const [key, value] of bySlug.entries()) {
+    if (key.toLowerCase() === lowerSlug) {
+      return value;
+    }
+  }
+  const slugifiedSearch = toSlug(slug);
+  const exactSlugified = bySlug.get(slugifiedSearch);
+  if (exactSlugified) return exactSlugified;
+  const lowerSlugified = slugifiedSearch.toLowerCase();
+  for (const [key, value] of bySlug.entries()) {
+    if (key.toLowerCase() === lowerSlugified) {
+      return value;
+    }
+  }
+  return null;
+}
+function findByFileNameCI(fileName, byFileName) {
+  const results = findByFileNameCaseInsensitive(fileName, byFileName);
+  if (results.length > 0) return results;
+  const slugifiedSearch = toSlug(fileName).replace(/-/g, " ");
+  const slugResults = findByFileNameCaseInsensitive(slugifiedSearch, byFileName);
+  if (slugResults.length > 0) return slugResults;
+  return null;
+}
+function resolveWikilink(wikilink, fileMap, currentFilePath) {
+  const cleanLink = wikilink.split("#")[0].split("#^")[0];
+  const bySlug = findBySlugCaseInsensitive(cleanLink, fileMap.bySlug);
+  if (bySlug) return bySlug;
+  const byAlias = fileMap.byAlias.get(cleanLink.toLowerCase());
+  if (byAlias && byAlias.length > 0) {
+    return resolveFromCandidates(byAlias, currentFilePath);
+  }
+  if (cleanLink.includes("/")) {
+    const possiblePaths = [
+      cleanLink + ".md",
+      cleanLink,
+      path5.join(path5.dirname(currentFilePath), cleanLink + ".md"),
+      path5.join(path5.dirname(currentFilePath), cleanLink)
+    ];
+    for (const possiblePath of possiblePaths) {
+      const normalized = path5.normalize(possiblePath);
+      const file = fileMap.byPath.get(normalized);
+      if (file) return file;
+    }
+  }
+  const candidates = findByFileNameCI(cleanLink, fileMap.byFileName);
+  if (!candidates || candidates.length === 0) {
+    const withoutExt = cleanLink.replace(/\.md$/, "");
+    const candidatesWithoutExt = findByFileNameCI(
+      withoutExt,
+      fileMap.byFileName
+    );
+    if (!candidatesWithoutExt || candidatesWithoutExt.length === 0) {
+      return null;
+    }
+    return resolveFromCandidates(candidatesWithoutExt, currentFilePath);
+  }
+  return resolveFromCandidates(candidates, currentFilePath);
+}
+function slugifyAnchor(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+function wikilinkToMarkdownLink(wikilink, alias, targetFile, options) {
+  let anchor = "";
+  if (wikilink.includes("#^")) ; else if (wikilink.includes("#")) {
+    const parts = wikilink.split("#");
+    anchor = "#" + slugifyAnchor(parts[1]);
+  }
+  const url = `${options.urlPrefix}/${targetFile.slug}${anchor}`;
+  const text = alias || targetFile.title || targetFile.fileName;
+  return { url, text };
+}
+function resolveMarkdownLink(href, fileMap, currentFilePath, options) {
+  if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("#") || href.startsWith(options.urlPrefix)) {
+    return href;
+  }
+  let cleanHref = href;
+  if (cleanHref.startsWith("/content/")) {
+    cleanHref = cleanHref.substring("/content/".length);
+  }
+  let anchor = "";
+  const anchorIndex = cleanHref.indexOf("#");
+  if (anchorIndex !== -1) {
+    anchor = cleanHref.substring(anchorIndex);
+    cleanHref = cleanHref.substring(0, anchorIndex);
+  }
+  const bySlug = findBySlugCaseInsensitive(cleanHref, fileMap.bySlug);
+  if (bySlug) {
+    return `${options.urlPrefix}/${bySlug.slug}${anchor}`;
+  }
+  const possiblePaths = [
+    cleanHref + ".md",
+    cleanHref,
+    path5.join(path5.dirname(currentFilePath), cleanHref + ".md"),
+    path5.join(path5.dirname(currentFilePath), cleanHref)
+  ];
+  for (const possiblePath of possiblePaths) {
+    const normalized = path5.normalize(possiblePath);
+    const file = fileMap.byPath.get(normalized);
+    if (file) {
+      return `${options.urlPrefix}/${file.slug}${anchor}`;
+    }
+  }
+  return `${options.urlPrefix}/${cleanHref}${anchor}`;
+}
+var Regex = {
+  HeaderOnly: /^#[^\^]+/,
+  BlockOnly: /^#\^.+/,
+  PageAndHeader: /.+#[^\^]+/,
+  PageAndBlock: /.+#\^.+/
+};
+function wikiToObsidian(wikiLink) {
+  const { value, alias } = wikiLink;
+  switch (true) {
+    case Regex.BlockOnly.test(value): {
+      const blockOnly = { type: "block", block: value.slice(2) };
+      if (alias) blockOnly.alias = alias;
+      return blockOnly;
+    }
+    case Regex.HeaderOnly.test(value): {
+      const headerOnly = { type: "header", header: value.slice(1) };
+      if (alias) headerOnly.alias = alias;
+      return headerOnly;
+    }
+    case Regex.PageAndBlock.test(value): {
+      const [page, block] = value.split("#^");
+      const pageAndBlock = { type: "page-block", page, block };
+      if (alias) pageAndBlock.alias = alias;
+      return pageAndBlock;
+    }
+    case Regex.PageAndHeader.test(value): {
+      const [page, header] = value.split("#");
+      const pageAndHeader = { type: "page-header", page, header };
+      if (alias) pageAndHeader.alias = alias;
+      return pageAndHeader;
+    }
+    default: {
+      const page = { type: "page", page: value };
+      if (alias) page.alias = alias;
+      return page;
+    }
+  }
+}
+function slugifyAnchor2(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+function createCustomToLink(options) {
+  const {
+    filesBySlug,
+    filesByName,
+    filesByAlias,
+    urlPrefix,
+    currentFile,
+    issueCollector
+  } = options;
+  return (wikiLink) => {
+    const obsidianLink = wikiToObsidian(wikiLink);
+    switch (obsidianLink.type) {
+      case "page":
+      case "page-header":
+      case "page-block": {
+        let targetFile = filesBySlug.get(obsidianLink.page);
+        if (!targetFile) {
+          const aliasCandidates = filesByAlias.get(
+            obsidianLink.page.toLowerCase()
+          );
+          if (aliasCandidates && aliasCandidates.length > 0) {
+            if (aliasCandidates.length === 1) {
+              targetFile = aliasCandidates[0];
+            } else if (currentFile) {
+              const currentDir = path5.dirname(currentFile.originalPath);
+              const sameDir = aliasCandidates.find(
+                (f) => path5.dirname(f.originalPath) === currentDir
+              );
+              targetFile = sameDir || aliasCandidates[0];
+            } else {
+              targetFile = aliasCandidates[0];
+            }
+          }
+        }
+        if (!targetFile) {
+          targetFile = filesByName.get(obsidianLink.page);
+        }
+        if (!targetFile) {
+          if (issueCollector && currentFile) {
+            issueCollector.addBrokenLink({
+              filePath: currentFile.originalPath,
+              linkText: obsidianLink.alias || obsidianLink.page,
+              linkTarget: obsidianLink.page,
+              linkType: "wiki"
+            });
+          }
+          return {
+            value: obsidianLink.alias || obsidianLink.page,
+            uri: `#broken-link:${obsidianLink.page}`
+          };
+        }
+        let uri = `${urlPrefix}/${targetFile.slug}`;
+        if (obsidianLink.type === "page-header") {
+          uri += `#${slugifyAnchor2(obsidianLink.header)}`;
+        }
+        return {
+          value: obsidianLink.alias || obsidianLink.page,
+          uri
+        };
+      }
+      case "header":
+        return {
+          value: obsidianLink.alias || `#${obsidianLink.header}`,
+          uri: `#${slugifyAnchor2(obsidianLink.header)}`
+        };
+      case "block":
+        return {
+          value: obsidianLink.alias || `#^${obsidianLink.block}`,
+          uri: ""
+        };
+      default: {
+        return { value: String(obsidianLink), uri: "" };
+      }
+    }
+  };
+}
+function resolveMarkdownLinkPath(linkPath, currentFilePath, filesByPath) {
+  if (linkPath.startsWith("http://") || linkPath.startsWith("https://") || linkPath.startsWith("mailto:") || linkPath.startsWith("#")) {
+    return null;
+  }
+  const cleanPath = linkPath.split("#")[0];
+  const currentDir = path5.dirname(currentFilePath);
+  const resolvedPath = path5.normalize(path5.join(currentDir, cleanPath));
+  const candidates = [resolvedPath, resolvedPath.replace(/\.md$/, "") + ".md"];
+  for (const candidate of candidates) {
+    const file = filesByPath.get(candidate);
+    if (file) return file;
+  }
+  return null;
+}
+var remarkMarkdownLinkResolver = (options) => {
+  const { filesByPath, urlPrefix, currentFilePath } = options;
+  return (tree) => {
+    visit(tree, "link", (node) => {
+      if (node.url && !node.url.startsWith(urlPrefix) && !node.url.startsWith("http")) {
+        const targetFile = resolveMarkdownLinkPath(
+          node.url,
+          currentFilePath,
+          filesByPath
+        );
+        if (targetFile) {
+          const anchorIndex = node.url.indexOf("#");
+          const anchor = anchorIndex !== -1 ? node.url.substring(anchorIndex) : "";
+          node.url = `${urlPrefix}/${targetFile.slug}${anchor}`;
+        } else {
+          const filename = node.url.replace(/\.md$/, "");
+          for (const [, file] of filesByPath.entries()) {
+            if (file.fileName === filename) {
+              const anchorIndex = node.url.indexOf("#");
+              const anchor = anchorIndex !== -1 ? node.url.substring(anchorIndex) : "";
+              node.url = `${urlPrefix}/${file.slug}${anchor}`;
+              break;
+            }
+          }
+        }
+      }
+    });
+  };
+};
+var remarkObsidianLink;
+var rehypeAutolinkHeadings;
+var rehypeExternalLinks;
+var createDefaultLogger = (debugLevel) => {
+  return (message, level = "info") => {
+    const levelNum = level === "debug" ? 3 : level === "info" ? 2 : level === "warn" ? 1 : 0;
+    if (levelNum <= debugLevel) {
+      const prefix = "[processor-core]";
+      switch (level) {
+        case "error":
+          console.error(`${prefix} ERROR: ${message}`);
+          break;
+        case "warn":
+          console.warn(`${prefix} WARN: ${message}`);
+          break;
+        case "debug":
+          console.log(`${prefix} DEBUG: ${message}`);
+          break;
+        default:
+          console.log(`${prefix} ${message}`);
+      }
+    }
+  };
+};
+var Processor = class {
+  config;
+  pluginManager;
+  issues;
+  log;
+  initialized = false;
+  constructor(options) {
+    this.config = options.config;
+    this.issues = new IssueCollector();
+    this.log = options.log ?? createDefaultLogger(this.config.debug?.level ?? 1);
+    this.pluginManager = new PluginManager({
+      config: this.config,
+      outputDir: this.resolveOutputDir(),
+      issues: this.issues,
+      log: this.log
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Initialization
+  // --------------------------------------------------------------------------
+  /**
+   * Initialize the processor and plugins
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.log("Initializing processor...", "info");
+    await this.pluginManager.initialize();
+    this.initialized = true;
+    this.log("Processor initialized", "info");
+  }
+  /**
+   * Dispose the processor and cleanup resources
+   */
+  async dispose() {
+    await this.pluginManager.dispose();
+    this.initialized = false;
+  }
+  // --------------------------------------------------------------------------
+  // Path Resolution
+  // --------------------------------------------------------------------------
+  resolveInputDir() {
+    const base = this.config.dir.base ?? process.cwd();
+    return path5.resolve(base, this.config.dir.input);
+  }
+  resolveOutputDir() {
+    const base = this.config.dir.base ?? process.cwd();
+    return path5.resolve(base, this.config.dir.output ?? "build");
+  }
+  // --------------------------------------------------------------------------
+  // Processing
+  // --------------------------------------------------------------------------
+  /**
+   * Process the folder and generate output
+   */
+  async process() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const inputDir = this.resolveInputDir();
+    const outputDir = this.resolveOutputDir();
+    this.log(`Processing folder: ${inputDir}`, "info");
+    this.log(`Output directory: ${outputDir}`, "info");
+    await ensureDir(outputDir);
+    const totalStart = Date.now();
+    const state = {
+      inputDir,
+      outputDir,
+      posts: [],
+      media: [],
+      slugManager: new SlugManager("number"),
+      issues: this.issues,
+      mediaPathMap: /* @__PURE__ */ new Map(),
+      cacheStats: {
+        mediaCacheHits: 0,
+        mediaCacheMisses: 0,
+        textEmbeddingCacheHits: 0,
+        textEmbeddingCacheMisses: 0,
+        imageEmbeddingCacheHits: 0,
+        imageEmbeddingCacheMisses: 0
+      },
+      report: {},
+      phaseTiming: /* @__PURE__ */ new Map()
+    };
+    if (!this.config.media?.skip) {
+      await this.timed(state, "media", () => this.processMedia(state));
+    } else {
+      this.log("Skipping media processing", "info");
+    }
+    await this.timed(state, "markdown", () => this.processMarkdownFiles(state));
+    await this.timed(state, "embeddings", () => this.generateEmbeddings(state));
+    await this.timed(state, "similarity", () => this.generateSimilarity(state));
+    await this.timed(state, "database", () => this.buildDatabase(state));
+    const outputFiles = await this.timed(state, "output", () => this.writeOutput(state));
+    const issueReport = this.issues.generateReport();
+    this.log(this.issues.getSummaryString(), "info");
+    const hasCacheActivity = state.cacheStats.mediaCacheHits > 0 || state.cacheStats.mediaCacheMisses > 0 || state.cacheStats.textEmbeddingCacheHits > 0 || state.cacheStats.imageEmbeddingCacheHits > 0;
+    if (hasCacheActivity) {
+      this.log(
+        `Cache stats: media ${state.cacheStats.mediaCacheHits}/${state.cacheStats.mediaCacheHits + state.cacheStats.mediaCacheMisses} hits, text embeddings ${state.cacheStats.textEmbeddingCacheHits}/${state.cacheStats.textEmbeddingCacheHits + state.cacheStats.textEmbeddingCacheMisses} hits, image embeddings ${state.cacheStats.imageEmbeddingCacheHits}/${state.cacheStats.imageEmbeddingCacheHits + state.cacheStats.imageEmbeddingCacheMisses} hits`,
+        "info"
+      );
+    }
+    const totalMs = Date.now() - totalStart;
+    const phases = {};
+    for (const [phase, ms] of state.phaseTiming) {
+      phases[phase] = ms;
+    }
+    const report = {
+      ...state.report,
+      timing: { totalMs, phases }
+    };
+    return {
+      posts: state.posts,
+      media: state.media,
+      outputDir,
+      outputFiles,
+      issues: issueReport,
+      cacheStats: this.config.cache ? state.cacheStats : void 0,
+      report
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Phase Timing
+  // --------------------------------------------------------------------------
+  async timed(state, phase, fn) {
+    const start = Date.now();
+    const result = await fn();
+    const elapsed = Date.now() - start;
+    state.phaseTiming.set(phase, elapsed);
+    if (elapsed > 0) {
+      this.log(`Phase "${phase}" completed in ${elapsed}ms`, "debug");
+    }
+    return result;
+  }
+  // --------------------------------------------------------------------------
+  // Media Processing
+  // --------------------------------------------------------------------------
+  async processMedia(state) {
+    this.log("Processing media files...", "info");
+    const imageProcessor = this.pluginManager.getPluginByKey("imageProcessor");
+    if (!imageProcessor) {
+      this.log("No image processor plugin, skipping media optimization", "debug");
+      return;
+    }
+    const mediaExtensions = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".avif", ".svg"];
+    const mediaFiles = [];
+    const findMedia = async (dir) => {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path5.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await findMedia(fullPath);
+        } else if (entry.isFile() && mediaExtensions.some((ext) => entry.name.toLowerCase().endsWith(ext))) {
+          mediaFiles.push(fullPath);
+        }
+      }
+    };
+    await findMedia(state.inputDir);
+    this.log(`Found ${mediaFiles.length} media files`, "info");
+    const mediaOutputDir = path5.join(state.outputDir, this.config.dir.mediaOutput ?? "_media");
+    await ensureDir(mediaOutputDir);
+    const imageSizes = this.config.media?.sizes ?? [];
+    const imageFormat = this.config.media?.format ?? "webp";
+    const imageQuality = this.config.media?.quality ?? 80;
+    const useHash = this.config.media?.useHash ?? true;
+    const useSharding = this.config.media?.useSharding ?? false;
+    for (const mediaPath of mediaFiles) {
+      try {
+        const relativePath2 = normalizePath(path5.relative(state.inputDir, mediaPath));
+        const fileName = path5.basename(mediaPath);
+        const fileBuffer = await fs.readFile(mediaPath);
+        const contentHash = hashBuffer(fileBuffer);
+        const shortContentHash = contentHash.substring(0, 16);
+        const mediaCache = this.config.cache?.media;
+        const cachedMedia = mediaCache?.get(contentHash);
+        if (cachedMedia) {
+          state.cacheStats.mediaCacheHits++;
+          this.log(`Cache hit for ${fileName} (${contentHash.substring(0, 8)}...)`, "debug");
+          const processedMedia = {
+            originalPath: relativePath2,
+            outputPath: cachedMedia.outputPath,
+            fileName,
+            type: "image",
+            metadata: {
+              width: cachedMedia.width,
+              height: cachedMedia.height,
+              format: cachedMedia.format,
+              size: cachedMedia.size,
+              originalSize: cachedMedia.originalSize,
+              hash: contentHash
+            },
+            sizes: cachedMedia.sizes.length > 0 ? cachedMedia.sizes.map((s) => ({
+              suffix: s.suffix,
+              outputPath: s.outputPath,
+              width: s.width,
+              height: s.height,
+              size: s.size
+            })) : void 0
+          };
+          state.media.push(processedMedia);
+          state.mediaPathMap.set(relativePath2, processedMedia);
+          continue;
+        }
+        state.cacheStats.mediaCacheMisses++;
+        let outputFileName;
+        let outputSubDir = mediaOutputDir;
+        if (useHash) {
+          outputFileName = `${shortContentHash}.${imageFormat}`;
+          if (useSharding) {
+            const shardDir = contentHash.substring(0, 2);
+            outputSubDir = path5.join(mediaOutputDir, shardDir);
+            await ensureDir(outputSubDir);
+          }
+        } else {
+          const fileNameWithoutExt = path5.basename(mediaPath, path5.extname(mediaPath));
+          outputFileName = `${fileNameWithoutExt}.${imageFormat}`;
+        }
+        const outputPath = path5.join(outputSubDir, outputFileName);
+        const stats = await getStats(mediaPath);
+        if (imageProcessor.canProcess(mediaPath)) {
+          const metadata = await imageProcessor.getMetadata(mediaPath);
+          const originalWidth = metadata.width;
+          const result = await imageProcessor.process(mediaPath, outputPath, {
+            format: imageFormat,
+            quality: imageQuality
+          });
+          const sizeVariants = [];
+          for (const sizeConfig of imageSizes) {
+            if (sizeConfig.width === null || sizeConfig.width >= originalWidth) {
+              continue;
+            }
+            try {
+              let sizeOutputFileName;
+              if (useHash) {
+                sizeOutputFileName = `${shortContentHash}-${sizeConfig.suffix}.${imageFormat}`;
+              } else {
+                const fileNameWithoutExt = path5.basename(mediaPath, path5.extname(mediaPath));
+                sizeOutputFileName = `${fileNameWithoutExt}-${sizeConfig.suffix}.${imageFormat}`;
+              }
+              const sizeOutputPath = path5.join(outputSubDir, sizeOutputFileName);
+              const sizeResult = await imageProcessor.process(mediaPath, sizeOutputPath, {
+                width: sizeConfig.width,
+                height: sizeConfig.height ?? void 0,
+                format: imageFormat,
+                quality: imageQuality
+              });
+              sizeVariants.push({
+                suffix: sizeConfig.suffix,
+                outputPath: normalizePath(path5.relative(state.outputDir, sizeResult.outputPath)),
+                width: sizeResult.width,
+                height: sizeResult.height,
+                size: sizeResult.size
+              });
+            } catch (sizeError) {
+              const sizeErrorMsg = sizeError instanceof Error ? sizeError.message : String(sizeError);
+              this.log(`Failed to generate ${sizeConfig.suffix} size for ${fileName}: ${sizeErrorMsg}`, "warn");
+            }
+          }
+          const processedMedia = {
+            originalPath: relativePath2,
+            outputPath: normalizePath(path5.relative(state.outputDir, result.outputPath)),
+            fileName,
+            type: "image",
+            metadata: {
+              width: result.width,
+              height: result.height,
+              format: result.format,
+              size: result.size,
+              originalSize: stats.size,
+              hash: contentHash
+            },
+            sizes: sizeVariants.length > 0 ? sizeVariants : void 0
+          };
+          state.media.push(processedMedia);
+          state.mediaPathMap.set(relativePath2, processedMedia);
+        } else {
+          const ext = path5.extname(mediaPath);
+          let copyOutputPath;
+          if (useHash) {
+            const copyFileName = `${shortContentHash}${ext}`;
+            copyOutputPath = path5.join(outputSubDir, copyFileName);
+          } else {
+            copyOutputPath = path5.join(outputSubDir, fileName);
+          }
+          await imageProcessor.copy(mediaPath, copyOutputPath);
+          const copiedMedia = {
+            originalPath: relativePath2,
+            outputPath: normalizePath(path5.relative(state.outputDir, copyOutputPath)),
+            fileName,
+            type: "media",
+            metadata: {
+              size: stats.size,
+              originalSize: stats.size,
+              hash: contentHash
+            }
+          };
+          state.media.push(copiedMedia);
+          state.mediaPathMap.set(relativePath2, copiedMedia);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.issues.addMediaProcessingError({
+          filePath: mediaPath,
+          mediaPath,
+          operation: "read",
+          errorMessage
+        });
+      }
+    }
+    this.log(`Processed ${state.media.length} media files`, "info");
+  }
+  // --------------------------------------------------------------------------
+  // Markdown Processing
+  // --------------------------------------------------------------------------
+  async processMarkdownFiles(state) {
+    this.log("Processing markdown files...", "info");
+    const mdFiles = await findMarkdownFiles(state.inputDir);
+    this.log(`Found ${mdFiles.length} markdown files`, "info");
+    const parsedFiles = [];
+    for (const filePath of mdFiles) {
+      try {
+        const content = await readText(filePath);
+        const stats = await getStats(filePath);
+        parsedFiles.push({ filePath, content, stats });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log(`Failed to read ${filePath}: ${errorMessage}`, "warn");
+      }
+    }
+    for (const { filePath, content, stats } of parsedFiles) {
+      try {
+        const post = await this.parseMarkdownFile(state, filePath, content, stats);
+        if (post) {
+          state.posts.push(post);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log(`Failed to process ${filePath}: ${errorMessage}`, "error");
+      }
+    }
+    const wikiLinksEnabled = this.config.pipeline?.wikiLinks !== false;
+    if (wikiLinksEnabled && state.posts.length > 0) {
+      await this.renderPostsWithLinks(state);
+    }
+    this.log(`Processed ${state.posts.length} posts`, "info");
+  }
+  /**
+   * Phase 1: Parse a markdown file — extract all metadata but use basic HTML.
+   * The markdown source is stored for Phase 2 re-rendering.
+   */
+  async parseMarkdownFile(state, filePath, content, stats) {
+    const relativePath2 = normalizePath(path5.relative(state.inputDir, filePath));
+    const fileName = getFileName(filePath);
+    const pipelineConfig = this.config.pipeline ?? {};
+    const result = await processMarkdown(content, {
+      gfm: pipelineConfig.gfm ?? true,
+      allowRawHtml: pipelineConfig.allowRawHtml ?? true
+    });
+    const isPublished = result.frontmatter.published !== false && result.frontmatter.draft !== true;
+    if (!isPublished && !this.config.content?.processAllFiles) {
+      this.log(`Skipping unpublished: ${relativePath2}`, "debug");
+      return null;
+    }
+    const parentFolder = path5.dirname(relativePath2);
+    const scope = this.config.content?.slugScope === "top-folder" ? relativePath2.split("/")[0] : void 0;
+    const slugInfo = state.slugManager.reserve(filePath, {
+      fileName,
+      parentFolder: parentFolder !== "." ? parentFolder : void 0,
+      frontmatterSlug: result.frontmatter.slug
+    }, scope);
+    if (slugInfo.wasModified) {
+      this.issues.addSlugConflict({
+        filePath: relativePath2,
+        originalSlug: slugInfo.originalSlug,
+        finalSlug: slugInfo.slug,
+        conflictingFiles: []
+      });
+    }
+    const plainText = mdastToText(result.mdast);
+    const headings = extractHeadings(result.mdast);
+    const toc = buildToc(headings);
+    const firstParagraph = extractFirstParagraph(result.mdast);
+    const wordCount = countWords(plainText);
+    const hash = hashContent(content);
+    const title = result.frontmatter.title || (headings.length > 0 && headings[0].depth === 1 ? headings[0].text : fileName);
+    const cover = this.resolveCover(
+      result.frontmatter,
+      relativePath2,
+      state.mediaPathMap
+    );
+    const post = {
+      hash,
+      slug: slugInfo.slug,
+      fileName,
+      title,
+      content: result.html,
+      markdown: result.markdown,
+      frontmatter: result.frontmatter,
+      plainText,
+      excerpt: firstParagraph,
+      wordCount,
+      toc,
+      originalPath: relativePath2,
+      metadata: {
+        createdAt: stats.created.toISOString(),
+        modifiedAt: stats.modified.toISOString(),
+        processedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    if (cover) {
+      post.cover = cover;
+    }
+    return post;
+  }
+  /**
+   * Phase 2: Build file maps from all parsed posts, then re-render each
+   * file's markdown through a pipeline that includes wiki-link resolution.
+   */
+  async renderPostsWithLinks(state) {
+    this.log("Phase 2: Rendering with wiki-link resolution...", "info");
+    if (!remarkObsidianLink) {
+      const [rolMod, rahMod, relMod] = await Promise.all([
+        import('remark-obsidian-link'),
+        import('rehype-autolink-headings'),
+        import('rehype-external-links')
+      ]);
+      remarkObsidianLink = rolMod.remarkObsidianLink;
+      rehypeAutolinkHeadings = rahMod.default ?? rahMod;
+      rehypeExternalLinks = relMod.default ?? relMod;
+    }
+    const fileMaps = buildFileMaps(state.posts);
+    const filesByName = /* @__PURE__ */ new Map();
+    for (const [name, posts] of fileMaps.byFileName) {
+      if (posts.length > 0) {
+        filesByName.set(name, posts[0]);
+      }
+    }
+    const urlPrefix = this.config.content?.notePathPrefix ?? "/content";
+    const pipelineConfig = this.config.pipeline ?? {};
+    const { unified: unified2 } = await import('unified');
+    const remarkParse2 = (await import('remark-parse')).default;
+    const remarkGfm2 = (await import('remark-gfm')).default;
+    const remarkRehype2 = (await import('remark-rehype')).default;
+    const rehypeRaw2 = (await import('rehype-raw')).default;
+    const rehypeSlug2 = (await import('rehype-slug')).default;
+    const rehypeStringify2 = (await import('rehype-stringify')).default;
+    for (let i = 0; i < state.posts.length; i++) {
+      const post = state.posts[i];
+      try {
+        const toLink = createCustomToLink({
+          filesBySlug: fileMaps.bySlug,
+          filesByName,
+          filesByPath: fileMaps.byPath,
+          filesByAlias: fileMaps.byAlias,
+          urlPrefix,
+          currentFile: post,
+          issueCollector: this.issues
+        });
+        let pipeline = unified2().use(remarkParse2);
+        if (pipelineConfig.gfm !== false) {
+          pipeline = pipeline.use(remarkGfm2);
+        }
+        pipeline = pipeline.use(remarkObsidianLink, { toLink }).use(remarkMarkdownLinkResolver, {
+          filesByPath: fileMaps.byPath,
+          urlPrefix,
+          currentFilePath: post.originalPath
+        }).use(remarkRehype2, {
+          allowDangerousHtml: pipelineConfig.allowRawHtml !== false
+        });
+        if (pipelineConfig.allowRawHtml !== false) {
+          pipeline = pipeline.use(rehypeRaw2);
+        }
+        pipeline = pipeline.use(rehypeSlug2).use(rehypeExternalLinks, { target: "_blank", rel: ["nofollow", "noopener", "noreferrer"] }).use(rehypeAutolinkHeadings, { behavior: "wrap" }).use(rehypeStringify2);
+        const file = await pipeline.process(post.markdown);
+        state.posts[i].content = String(file);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log(
+          `Failed to render links for ${post.originalPath}: ${errorMessage}`,
+          "warn"
+        );
+      }
+    }
+  }
+  /**
+   * Build absolute URL from relative path using domain config
+   * URL structure: {domain}/_shared/medias/{filename}
+   */
+  buildAbsoluteUrl(relativePath2) {
+    const domain = this.config.media?.domain;
+    if (!domain) {
+      return void 0;
+    }
+    const filename = relativePath2.split("/").pop();
+    if (!filename) {
+      return void 0;
+    }
+    const baseUrl = domain.replace(/\/$/, "");
+    return `${baseUrl}/_shared/medias/${filename}`;
+  }
+  /**
+   * Resolve cover image from frontmatter
+   * Returns PostCover if found, PostCoverError if specified but not found, undefined if not specified
+   */
+  resolveCover(frontmatter, postPath, mediaPathMap) {
+    const coverFields = ["cover", "image", "thumbnail", "coverImage", "cover_image"];
+    let coverValue;
+    for (const field of coverFields) {
+      const value = frontmatter[field];
+      if (typeof value === "string" && value.length > 0) {
+        coverValue = value;
+        break;
+      }
+    }
+    if (!coverValue) {
+      return void 0;
+    }
+    const postDir = path5.dirname(postPath);
+    const pathsToTry = [
+      normalizePath(coverValue),
+      // Direct path from root
+      normalizePath(path5.join(postDir, coverValue)),
+      // Relative to post directory
+      normalizePath(coverValue.replace(/^\//, ""))
+      // Remove leading slash if present
+    ];
+    let mediaInfo;
+    for (const tryPath of pathsToTry) {
+      mediaInfo = mediaPathMap.get(tryPath);
+      if (mediaInfo) {
+        break;
+      }
+    }
+    if (!mediaInfo) {
+      this.log(`Cover image not found for "${postPath}": "${coverValue}"`, "warn");
+      return {
+        original: coverValue,
+        error: `Cover image not found: "${coverValue}"`
+      };
+    }
+    const cover = {
+      original: coverValue,
+      path: mediaInfo.outputPath,
+      url: this.buildAbsoluteUrl(mediaInfo.outputPath),
+      hash: mediaInfo.metadata?.hash,
+      width: mediaInfo.metadata?.width,
+      height: mediaInfo.metadata?.height,
+      sizes: mediaInfo.sizes?.map((s) => ({
+        suffix: s.suffix,
+        path: s.outputPath,
+        url: this.buildAbsoluteUrl(s.outputPath),
+        width: s.width,
+        height: s.height
+      }))
+    };
+    return cover;
+  }
+  // --------------------------------------------------------------------------
+  // Embeddings
+  // --------------------------------------------------------------------------
+  async generateEmbeddings(state) {
+    const textEmbedder = this.pluginManager.getPluginByKey("textEmbedder");
+    if (!textEmbedder || textEmbedder.dimensions === 0) {
+      this.log("No text embedder plugin, skipping embeddings", "debug");
+      return;
+    }
+    this.log("Generating text embeddings...", "info");
+    const textEmbeddingsCache = this.config.cache?.textEmbeddings;
+    try {
+      const uncachedPosts = [];
+      const cachedCount = { hits: 0, misses: 0 };
+      for (let i = 0; i < state.posts.length; i++) {
+        const post = state.posts[i];
+        if (!post) continue;
+        const cachedEmbedding = textEmbeddingsCache?.get(post.hash);
+        if (cachedEmbedding) {
+          post.embedding = cachedEmbedding;
+          cachedCount.hits++;
+          state.cacheStats.textEmbeddingCacheHits++;
+        } else {
+          uncachedPosts.push({ index: i, text: post.plainText });
+          cachedCount.misses++;
+          state.cacheStats.textEmbeddingCacheMisses++;
+        }
+      }
+      if (uncachedPosts.length > 0) {
+        const texts = uncachedPosts.map((p) => p.text);
+        const embeddings = await textEmbedder.batchEmbed(texts);
+        for (let i = 0; i < uncachedPosts.length; i++) {
+          const postInfo = uncachedPosts[i];
+          if (!postInfo) continue;
+          const post = state.posts[postInfo.index];
+          if (post && embeddings[i]) {
+            post.embedding = embeddings[i];
+          }
+        }
+        this.log(`Generated ${embeddings.length} text embeddings (${cachedCount.hits} from cache)`, "info");
+      } else {
+        this.log(`All ${cachedCount.hits} text embeddings loaded from cache`, "info");
+      }
+      const postsWithEmbeddings = state.posts.filter((p) => p.embedding && p.embedding.length > 0);
+      state.report.postEmbeddings = {
+        filesProcessed: postsWithEmbeddings.length,
+        dimensions: textEmbedder.dimensions,
+        model: textEmbedder.model
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.issues.addEmbeddingError({
+        embeddingType: "text",
+        operation: "batch",
+        errorMessage
+      });
+    }
+    const imageEmbedder = this.pluginManager.getPluginByKey("imageEmbedder");
+    if (imageEmbedder && imageEmbedder.dimensions > 0 && state.media.length > 0) {
+      this.log("Generating image embeddings...", "info");
+      const imageEmbeddingsCache = this.config.cache?.imageEmbeddings;
+      let cachedCount = 0;
+      let generatedCount = 0;
+      for (const media of state.media) {
+        if (media.type === "image") {
+          const mediaHash = media.metadata?.hash;
+          const cachedEmbedding = mediaHash ? imageEmbeddingsCache?.get(mediaHash) : void 0;
+          if (cachedEmbedding) {
+            media.embedding = cachedEmbedding;
+            cachedCount++;
+            state.cacheStats.imageEmbeddingCacheHits++;
+          } else {
+            state.cacheStats.imageEmbeddingCacheMisses++;
+            try {
+              const mediaPath = path5.join(state.outputDir, media.outputPath);
+              const embedding = await imageEmbedder.embedFile(mediaPath);
+              media.embedding = embedding;
+              generatedCount++;
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              this.issues.addEmbeddingError({
+                filePath: media.originalPath,
+                embeddingType: "image",
+                operation: "embed",
+                errorMessage
+              });
+            }
+          }
+        }
+      }
+      this.log(`Image embeddings: ${generatedCount} generated, ${cachedCount} from cache`, "info");
+      const mediaWithEmbeddings = state.media.filter((m) => m.embedding && m.embedding.length > 0);
+      state.report.mediaEmbeddings = {
+        filesProcessed: mediaWithEmbeddings.length,
+        dimensions: imageEmbedder.dimensions,
+        model: imageEmbedder.model
+      };
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Similarity
+  // --------------------------------------------------------------------------
+  async generateSimilarity(state) {
+    const similarity = this.pluginManager.getPluginByKey("similarity");
+    if (!similarity) {
+      this.log("No similarity plugin, skipping similarity computation", "debug");
+      return;
+    }
+    this.log("Generating similarity data...", "info");
+    try {
+      const result = await similarity.generateSimilarityMap(state.posts);
+      const similarityPath = path5.join(state.outputDir, OUTPUT_FILES.SIMILARITY);
+      await writeJson(similarityPath, {
+        pairwiseScores: Object.fromEntries(result.pairwiseScores),
+        similarPosts: Object.fromEntries(result.similarPosts),
+        metadata: result.metadata
+      });
+      const simConfig = this.config.similarity;
+      state.report.similarity = {
+        pairsComputed: result.metadata.pairCount,
+        topN: simConfig?.topN ?? 5,
+        postsWithEmbeddings: result.metadata.postCount
+      };
+      this.log(
+        `Generated similarity data: ${result.metadata.pairCount} pairs`,
+        "info"
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log(`Failed to generate similarity: ${errorMessage}`, "error");
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Database
+  // --------------------------------------------------------------------------
+  async buildDatabase(state) {
+    const database = this.pluginManager.getPluginByKey("database");
+    if (!database) {
+      this.log("No database plugin, skipping database generation", "debug");
+      return;
+    }
+    this.log("Building database...", "info");
+    try {
+      const result = await database.build({
+        posts: state.posts,
+        media: state.media
+      });
+      this.log(
+        `Database built: ${result.tables.length} tables, ${result.hasVectorSearch ? "with" : "without"} vector search`,
+        "info"
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log(`Failed to build database: ${errorMessage}`, "error");
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Output
+  // --------------------------------------------------------------------------
+  async writeOutput(state) {
+    const { outputDir, posts, media } = state;
+    this.log("Writing output files...", "info");
+    const postsPath = path5.join(outputDir, "posts.json");
+    const mediaPath = path5.join(outputDir, "medias.json");
+    const slugMapPath = path5.join(outputDir, "posts-slug-map.json");
+    const pathMapPath = path5.join(outputDir, "posts-path-map.json");
+    const issuesPath = path5.join(outputDir, "processor-issues.json");
+    const slugMap = {};
+    const pathMap = {};
+    for (const post of posts) {
+      slugMap[post.slug] = post.hash;
+      pathMap[post.originalPath] = post.hash;
+    }
+    const writePromises = [
+      writeJson(postsPath, posts),
+      writeJson(mediaPath, media),
+      writeJson(slugMapPath, slugMap),
+      writeJson(pathMapPath, pathMap),
+      writeJson(issuesPath, this.issues.generateReport())
+    ];
+    const textEmbeddingMap = {};
+    let hasTextEmbeddings = false;
+    for (const post of posts) {
+      if (post.embedding && post.embedding.length > 0) {
+        textEmbeddingMap[post.hash] = post.embedding;
+        hasTextEmbeddings = true;
+      }
+    }
+    if (hasTextEmbeddings) {
+      const textEmbPath = path5.join(outputDir, OUTPUT_FILES.TEXT_EMBEDDINGS);
+      writePromises.push(writeJson(textEmbPath, textEmbeddingMap));
+    }
+    const imageEmbeddingMap = {};
+    let hasImageEmbeddings = false;
+    for (const m of media) {
+      const mediaHash = m.metadata?.hash;
+      if (mediaHash && m.embedding && m.embedding.length > 0) {
+        imageEmbeddingMap[mediaHash] = m.embedding;
+        hasImageEmbeddings = true;
+      }
+    }
+    if (hasImageEmbeddings) {
+      const imageEmbPath = path5.join(outputDir, OUTPUT_FILES.IMAGE_EMBEDDINGS);
+      writePromises.push(writeJson(imageEmbPath, imageEmbeddingMap));
+    }
+    await Promise.all(writePromises);
+    this.log(`Output written to ${outputDir}`, "info");
+    return {
+      posts: postsPath,
+      media: mediaPath,
+      slugMap: slugMapPath,
+      pathMap: pathMapPath,
+      issues: issuesPath
+    };
+  }
+};
+var createProcessor = async (config) => {
+  const processor = new Processor({ config });
+  await processor.initialize();
+  return processor;
+};
+var processFolder = async (config) => {
+  const processor = await createProcessor(config);
+  try {
+    return await processor.process();
+  } finally {
+    await processor.dispose();
+  }
+};
+var processVault = processFolder;
+
+export { DEFAULT_PIPELINE_OPTIONS, IssueCollector, Processor, SlugManager, buildFileMaps, buildToc, calculateSummary, combineHashes, copyFile, countWords, createBasePipeline, createCustomToLink, createPathVariations, createProcessor, ensureDir, estimateReadingTime, extractFirstParagraph, extractHeadings, fileExists, filterIssues, findByFileNameCaseInsensitive, findFiles, findMarkdownFiles, generateBaseSlug, generateIssueReport, getContentStats, getExtension, getFileName, getStats, hashBuffer, hashContent, hastToHtml, mdastToHast, mdastToText, normalizePath, parseFrontmatter, parseToMdast, processFolder, processMarkdown, processVault, readJson, readText, relativePath, remarkMarkdownLinkResolver, resolveFile, resolveFromCandidates, resolveMarkdownLink, resolveMarkdownLinkPath, resolveSlugConflict, resolveWikilink, shortHash, toSlug, wikiToObsidian, wikilinkToMarkdownLink, writeJson, writeText };