folderblog 0.0.2 → 0.0.3

package/dist/local/index.js

@@ -0,0 +1,772 @@
+import { FolderBlogError, NotFoundError } from '../chunk-XQD3UUL5.js';
+import { loadJsonFile } from '../chunk-Q6EXKX6K.js';
+import { isBrokenLinkIssue, isSlugConflictIssue, isMissingMediaIssue } from '../chunk-D26H5722.js';
+import '../chunk-3RG5ZIWI.js';
+import { resolve, join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import MiniSearch from 'minisearch';
+
+// src/local/cache.ts
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 500) {
+    this.maxSize = Math.max(1, maxSize);
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    if (this.map.size >= this.maxSize) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) {
+        this.map.delete(oldest);
+      }
+    }
+    this.map.set(key, value);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+function getPostDate(post) {
+  return post.frontmatter?.date || post.metadata?.createdAt || "";
+}
+function comparePostsFeaturedDate(a, b) {
+  const aFeatured = a.frontmatter?.featured === true;
+  const bFeatured = b.frontmatter?.featured === true;
+  if (aFeatured && !bFeatured) return -1;
+  if (!aFeatured && bFeatured) return 1;
+  const aDate = new Date(getPostDate(a) || 0);
+  const bDate = new Date(getPostDate(b) || 0);
+  return bDate.getTime() - aDate.getTime();
+}
+var PostStore = class {
+  posts;
+  bySlug;
+  byHash;
+  byPath;
+  cache;
+  _slugMap;
+  _slugs;
+  constructor(dir, cache) {
+    this.cache = cache;
+    const postsPath = join(dir, "posts.json");
+    if (!existsSync(postsPath)) {
+      throw new FolderBlogError(
+        `posts.json not found in ${dir} \u2014 did you run the build?`
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(readFileSync(postsPath, "utf-8"));
+    } catch (e) {
+      throw new FolderBlogError(
+        `Failed to parse posts.json in ${dir}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    this.posts = data.sort((a, b) => {
+      return getPostDate(b).localeCompare(getPostDate(a));
+    });
+    this.bySlug = /* @__PURE__ */ new Map();
+    this.byHash = /* @__PURE__ */ new Map();
+    this.byPath = /* @__PURE__ */ new Map();
+    for (const post of this.posts) {
+      this.bySlug.set(post.slug, post);
+      this.byHash.set(post.hash, post);
+      this.byPath.set(post.originalPath, post);
+    }
+    const defaultSlugMap = {};
+    for (const post of this.posts) defaultSlugMap[post.slug] = post.hash;
+    this._slugMap = loadJsonFile(join(dir, "posts-slug-map.json"), defaultSlugMap);
+    this._slugs = Object.keys(this._slugMap);
+  }
+  /** Resolve a slug or hash to a hash, using the built-in indexes */
+  resolveHash(slugOrHash) {
+    if (this.byHash.has(slugOrHash)) return slugOrHash;
+    const post = this.bySlug.get(slugOrHash);
+    return post?.hash;
+  }
+  list() {
+    return this.posts;
+  }
+  lookup(cachePrefix, map, key) {
+    const cacheKey = `${cachePrefix}:${key}`;
+    if (this.cache) {
+      const cached = this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    const post = map.get(key);
+    if (!post) throw new NotFoundError("Post", key);
+    if (this.cache) this.cache.set(cacheKey, post);
+    return post;
+  }
+  get(slug) {
+    return this.lookup("slug", this.bySlug, slug);
+  }
+  getByHash(hash) {
+    return this.lookup("hash", this.byHash, hash);
+  }
+  getByPath(path) {
+    return this.lookup("path", this.byPath, path);
+  }
+  recent(count = 10) {
+    return this.posts.slice(0, count);
+  }
+  get count() {
+    return this.posts.length;
+  }
+  /** Slug → hash mapping */
+  get slugMap() {
+    return this._slugMap;
+  }
+  /** All available slugs (cached) */
+  slugs() {
+    return this._slugs;
+  }
+  /** Query posts by frontmatter values */
+  where(query) {
+    return this.posts.filter((post) => {
+      for (const [key, value] of Object.entries(query)) {
+        const fm = post.frontmatter?.[key];
+        if (fm !== value) return false;
+      }
+      return true;
+    });
+  }
+  /** Shorthand for where({ featured: true }) */
+  featured() {
+    return this.where({ featured: true });
+  }
+  /** Published posts: not draft, not hidden, not future-dated */
+  published() {
+    const now = /* @__PURE__ */ new Date();
+    return this.posts.filter((post) => {
+      if (post.frontmatter?.draft === true) return false;
+      if (post.frontmatter?.hidden === true) return false;
+      const dateStr = post.frontmatter?.date;
+      if (dateStr) {
+        if (new Date(dateStr).getTime() > now.getTime()) return false;
+      }
+      return true;
+    });
+  }
+  /** Sort posts: featured first, then by date descending */
+  sorted(posts) {
+    return [...posts ?? this.posts].sort(comparePostsFeaturedDate);
+  }
+};
+function extractSection(post) {
+  const path = post.originalPath || "";
+  const parts = path.split("/");
+  if (parts.length >= 2) {
+    return parts[1]?.replace(/^\d+-/, "") || "general";
+  }
+  return "general";
+}
+function isScheduled(post) {
+  const dateStr = post.frontmatter?.date;
+  if (!dateStr) return false;
+  return new Date(dateStr).getTime() > Date.now();
+}
+function isDraft(post) {
+  return post.frontmatter?.draft === true;
+}
+function isHidden(post) {
+  return post.frontmatter?.hidden === true;
+}
+function isPublished(post) {
+  return !isDraft(post) && !isHidden(post) && !isScheduled(post);
+}
+var DEFAULT_BOOST = {
+  title: 3,
+  slug: 2,
+  excerpt: 2
+};
+var SearchEngine = class {
+  index;
+  postsBySlug;
+  defaultFuzzy;
+  defaultPrefix;
+  defaultBoost;
+  constructor(posts, options) {
+    this.defaultBoost = options?.boost ?? DEFAULT_BOOST;
+    this.defaultFuzzy = options?.fuzzy ?? 0.2;
+    this.defaultPrefix = options?.prefix ?? true;
+    this.postsBySlug = /* @__PURE__ */ new Map();
+    for (const post of posts) {
+      this.postsBySlug.set(post.slug, post);
+    }
+    this.index = new MiniSearch({
+      fields: ["title", "slug", "excerpt", "plainText"],
+      storeFields: ["title", "slug", "excerpt"],
+      idField: "slug",
+      searchOptions: {
+        boost: this.defaultBoost,
+        fuzzy: this.defaultFuzzy,
+        prefix: this.defaultPrefix
+      }
+    });
+    this.index.addAll(
+      posts.map((p) => ({
+        slug: p.slug,
+        title: p.title,
+        excerpt: p.excerpt,
+        plainText: p.plainText
+      }))
+    );
+  }
+  search(query, options) {
+    if (!query.trim()) return [];
+    const results = this.index.search(query, {
+      boost: options?.boost ?? this.defaultBoost,
+      fuzzy: options?.fuzzy ?? this.defaultFuzzy,
+      prefix: options?.prefix ?? this.defaultPrefix
+    });
+    const limit = options?.limit ?? 10;
+    return results.slice(0, limit).map((r) => ({
+      slug: r.id,
+      title: r.title,
+      excerpt: r.excerpt,
+      score: r.score
+    }));
+  }
+  autoSuggest(term, limit = 5) {
+    if (!term.trim()) return [];
+    const suggestions = this.index.autoSuggest(term, {
+      boost: this.defaultBoost,
+      fuzzy: this.defaultFuzzy,
+      prefix: this.defaultPrefix
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const suggestion of suggestions) {
+      if (results.length >= limit) break;
+      const searchResults = this.index.search(suggestion.suggestion, {
+        boost: this.defaultBoost,
+        fuzzy: false,
+        prefix: true
+      });
+      for (const r of searchResults) {
+        if (results.length >= limit) break;
+        const slug = r.id;
+        if (seen.has(slug)) continue;
+        seen.add(slug);
+        const post = this.postsBySlug.get(slug);
+        if (post) {
+          results.push({ slug, title: post.title });
+        }
+      }
+    }
+    return results;
+  }
+};
+var SimilarityService = class {
+  data;
+  lookup;
+  defaultTopN;
+  constructor(dir, lookup, options) {
+    this.defaultTopN = options?.topN ?? 5;
+    this.lookup = lookup;
+    const simPath = join(dir, "similarity.json");
+    const fileExists = existsSync(simPath);
+    const shouldLoad = options?.enabled ?? fileExists;
+    this.data = shouldLoad && fileExists ? loadJsonFile(simPath, null) : null;
+  }
+  get available() {
+    return this.data !== null;
+  }
+  getSimilar(slugOrHash, count) {
+    if (!this.data) return [];
+    const n = count ?? this.defaultTopN;
+    const hash = this.lookup.resolveHash(slugOrHash);
+    if (!hash) return [];
+    const entries = this.data[hash];
+    if (!entries) return [];
+    return entries.slice(0, n).map((entry) => {
+      const post = this.lookup.byHash.get(entry.hash);
+      if (!post) return null;
+      return { post, score: entry.score };
+    }).filter((r) => r !== null);
+  }
+};
+
+// src/local/tags.ts
+var CountedIndex = class {
+  counts = /* @__PURE__ */ new Map();
+  posts = /* @__PURE__ */ new Map();
+  add(key, post) {
+    const normalized = key.trim().toLowerCase();
+    if (!normalized) return;
+    this.counts.set(normalized, (this.counts.get(normalized) ?? 0) + 1);
+    const arr = this.posts.get(normalized);
+    if (arr) {
+      arr.push(post);
+    } else {
+      this.posts.set(normalized, [post]);
+    }
+  }
+  lookup(key) {
+    return this.posts.get(key.trim().toLowerCase()) ?? [];
+  }
+};
+var TagIndex = class {
+  tags;
+  cats;
+  constructor(posts) {
+    this.tags = new CountedIndex();
+    this.cats = new CountedIndex();
+    for (const post of posts) {
+      const fm = post.frontmatter;
+      for (const tag of Array.isArray(fm?.tags) ? fm.tags : []) {
+        this.tags.add(tag, post);
+      }
+      const categories = Array.isArray(fm?.categories) ? [...fm.categories] : [];
+      if (typeof fm?.category === "string" && fm.category.trim()) {
+        categories.push(fm.category);
+      }
+      for (const cat of categories) {
+        this.cats.add(cat, post);
+      }
+    }
+  }
+  listTags() {
+    return Array.from(this.tags.counts.entries()).map(([tag, count]) => ({ tag, count })).sort((a, b) => b.count - a.count);
+  }
+  postsByTag(tag) {
+    return this.tags.lookup(tag);
+  }
+  listCategories() {
+    return Array.from(this.cats.counts.entries()).map(([category, count]) => ({ category, count })).sort((a, b) => b.count - a.count);
+  }
+  postsByCategory(category) {
+    return this.cats.lookup(category);
+  }
+  get tagCount() {
+    return this.tags.counts.size;
+  }
+  get categoryCount() {
+    return this.cats.counts.size;
+  }
+};
+var MediaStore = class {
+  items;
+  byPath;
+  constructor(dir) {
+    this.items = loadJsonFile(join(dir, "media.json"), []);
+    this.byPath = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      this.byPath.set(item.originalPath, item);
+    }
+  }
+  list() {
+    return this.items;
+  }
+  get(path) {
+    const item = this.byPath.get(path);
+    if (!item) throw new NotFoundError("Media", path);
+    return item;
+  }
+  get count() {
+    return this.items.length;
+  }
+};
+var GraphService = class {
+  /** hash → set of hashes this post links to */
+  outgoing;
+  /** hash → set of hashes that link to this post */
+  incoming;
+  lookup;
+  available;
+  constructor(dir, lookup) {
+    this.lookup = lookup;
+    this.outgoing = /* @__PURE__ */ new Map();
+    this.incoming = /* @__PURE__ */ new Map();
+    const posts = lookup.list();
+    let hasLinks = false;
+    for (const post of posts) {
+      if (post.links && post.links.length > 0) {
+        hasLinks = true;
+        const out = new Set(post.links);
+        this.outgoing.set(post.hash, out);
+        for (const targetHash of out) {
+          let inc = this.incoming.get(targetHash);
+          if (!inc) {
+            inc = /* @__PURE__ */ new Set();
+            this.incoming.set(targetHash, inc);
+          }
+          inc.add(post.hash);
+        }
+      }
+    }
+    const graphPath = join(dir, "graph.json");
+    if (existsSync(graphPath)) {
+      try {
+        const graphData = JSON.parse(readFileSync(graphPath, "utf-8"));
+        for (const edge of graphData.edges) {
+          if (edge.type === "POST_LINKS_TO_POST") {
+            hasLinks = true;
+            let out = this.outgoing.get(edge.source);
+            if (!out) {
+              out = /* @__PURE__ */ new Set();
+              this.outgoing.set(edge.source, out);
+            }
+            out.add(edge.target);
+            let inc = this.incoming.get(edge.target);
+            if (!inc) {
+              inc = /* @__PURE__ */ new Set();
+              this.incoming.set(edge.target, inc);
+            }
+            inc.add(edge.source);
+          }
+        }
+      } catch {
+      }
+    }
+    this.available = hasLinks;
+  }
+  getRelated(slugOrHash, count = 5, fallbackSimilar) {
+    const hash = this.lookup.resolveHash(slugOrHash);
+    if (!hash) return [];
+    const sourcePost = this.lookup.byHash.get(hash);
+    const sourceTags = new Set(
+      sourcePost.frontmatter?.tags ?? []
+    );
+    const outgoing = this.outgoing.get(hash) ?? /* @__PURE__ */ new Set();
+    const incoming = this.incoming.get(hash) ?? /* @__PURE__ */ new Set();
+    if (outgoing.size === 0 && incoming.size === 0) {
+      if (fallbackSimilar) {
+        return fallbackSimilar(slugOrHash, count).map((r) => ({
+          post: r.post,
+          score: r.score,
+          reasons: ["similarity"]
+        }));
+      }
+      return [];
+    }
+    const scores = /* @__PURE__ */ new Map();
+    const addScore = (targetHash, points, reason) => {
+      if (targetHash === hash) return;
+      if (!this.lookup.byHash.has(targetHash)) return;
+      const entry = scores.get(targetHash) ?? { score: 0, reasons: [] };
+      entry.score += points;
+      entry.reasons.push(reason);
+      scores.set(targetHash, entry);
+    };
+    for (const target of outgoing) {
+      if (incoming.has(target)) {
+        addScore(target, 3, "mutual-link");
+      } else {
+        addScore(target, 2, "outgoing-link");
+      }
+    }
+    for (const source of incoming) {
+      if (!outgoing.has(source)) {
+        addScore(source, 1, "incoming-link");
+      }
+    }
+    if (sourceTags.size > 0) {
+      for (const post of this.lookup.list()) {
+        if (post.hash === hash) continue;
+        const postTags = post.frontmatter?.tags ?? [];
+        let shared = 0;
+        for (const tag of postTags) {
+          if (sourceTags.has(tag)) shared++;
+        }
+        if (shared > 0) {
+          addScore(post.hash, shared * 0.5, `shared-tags(${shared})`);
+        }
+      }
+    }
+    return Array.from(scores.entries()).sort((a, b) => b[1].score - a[1].score).slice(0, count).map(([targetHash, { score, reasons }]) => ({
+      post: this.lookup.byHash.get(targetHash),
+      score,
+      reasons
+    }));
+  }
+};
+
+// src/local/issues.ts
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+var IssueIndex = class {
+  report;
+  constructor(report) {
+    this.report = report;
+  }
+  /** All issues */
+  all() {
+    return this.report.issues;
+  }
+  /** The summary (counts, affected files, etc.) */
+  get summary() {
+    return this.report.summary;
+  }
+  /** Build metadata (start/end time, version) */
+  get metadata() {
+    return this.report.metadata;
+  }
+  /** Total issue count */
+  get count() {
+    return this.report.summary.totalIssues;
+  }
+  /** Whether there are any errors */
+  get hasErrors() {
+    return this.report.summary.errorCount > 0;
+  }
+  /** Whether there are any warnings */
+  get hasWarnings() {
+    return this.report.summary.warningCount > 0;
+  }
+  // --------------------------------------------------------------------------
+  // Filter by severity
+  // --------------------------------------------------------------------------
+  errors() {
+    return this.report.issues.filter((i) => i.severity === "error");
+  }
+  warnings() {
+    return this.report.issues.filter((i) => i.severity === "warning");
+  }
+  info() {
+    return this.report.issues.filter((i) => i.severity === "info");
+  }
+  // --------------------------------------------------------------------------
+  // Filter by category (typed returns)
+  // --------------------------------------------------------------------------
+  brokenLinks() {
+    return this.report.issues.filter(isBrokenLinkIssue);
+  }
+  slugConflicts() {
+    return this.report.issues.filter(isSlugConflictIssue);
+  }
+  missingMedia() {
+    return this.report.issues.filter(isMissingMediaIssue);
+  }
+  /** Filter by category name */
+  byCategory(category) {
+    return this.report.issues.filter((i) => i.category === category);
+  }
+  /** Filter by module name */
+  byModule(module) {
+    return this.report.issues.filter((i) => i.module === module);
+  }
+  /** Filter by file path */
+  byFile(filePath) {
+    return this.report.issues.filter((i) => i.filePath === filePath);
+  }
+  /** Generic filter with multiple criteria (AND) */
+  filter(options) {
+    let filtered = [...this.report.issues];
+    if (options.severity) {
+      const vals = asArray(options.severity);
+      filtered = filtered.filter((i) => vals.includes(i.severity));
+    }
+    if (options.category) {
+      const vals = asArray(options.category);
+      filtered = filtered.filter((i) => vals.includes(i.category));
+    }
+    if (options.module) {
+      const vals = asArray(options.module);
+      filtered = filtered.filter((i) => vals.includes(i.module));
+    }
+    if (options.filePath) {
+      const vals = asArray(options.filePath);
+      filtered = filtered.filter((i) => i.filePath != null && vals.includes(i.filePath));
+    }
+    return filtered;
+  }
+  /** Get affected file paths */
+  affectedFiles() {
+    const files = /* @__PURE__ */ new Set();
+    for (const issue of this.report.issues) {
+      if (issue.filePath) files.add(issue.filePath);
+    }
+    return [...files];
+  }
+  /** Human-readable summary string */
+  summaryString() {
+    const { errorCount, warningCount, infoCount } = this.report.summary;
+    const parts = [];
+    if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+    if (warningCount > 0) parts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
+    if (infoCount > 0) parts.push(`${infoCount} info`);
+    return parts.length > 0 ? `${parts.join(", ")}` : "No issues";
+  }
+};
+
+// src/local/view.ts
+function toPost(p) {
+  return {
+    fileName: p.fileName,
+    slug: p.slug,
+    hash: p.hash,
+    frontmatter: {
+      ...p.frontmatter,
+      title: p.frontmatter?.title || p.title
+    },
+    firstParagraphText: p.excerpt ?? "",
+    plain: p.plainText ?? "",
+    html: p.content ?? "",
+    toc: (p.toc ?? []).map((t) => ({
+      id: t.slug,
+      title: t.text,
+      depth: t.depth
+    })),
+    originalFilePath: p.originalPath,
+    wordCount: p.wordCount ?? 0,
+    firstImage: p.firstImage,
+    cover: p.frontmatter?.cover ?? void 0,
+    links: p.links
+  };
+}
+
+// src/local/index.ts
+var FolderBlogLocal = class {
+  postStore;
+  searchEngine;
+  similarityService;
+  graphService;
+  tagIndex;
+  mediaStore;
+  issueReport;
+  issueIndex;
+  debug;
+  mapPostFn;
+  constructor(options) {
+    const dir = resolve(options.dir);
+    this.debug = options.debug ?? false;
+    this.mapPostFn = options.mapPost ?? null;
+    if (this.debug) console.log(`[folderblog/local] Loading from ${dir}`);
+    const cache = options.cache?.enabled ?? true ? new LRUCache(options.cache?.maxSize ?? 500) : null;
+    this.postStore = new PostStore(dir, cache);
+    const allPosts = this.postStore.list();
+    if (this.debug) console.log(`[folderblog/local] Loaded ${allPosts.length} posts`);
+    const searchEnabled = options.search?.enabled ?? true;
+    this.searchEngine = searchEnabled ? new SearchEngine(allPosts, {
+      boost: options.search?.boost,
+      fuzzy: options.search?.fuzzy,
+      prefix: options.search?.prefix
+    }) : null;
+    this.similarityService = new SimilarityService(dir, this.postStore, {
+      enabled: options.similarity?.enabled,
+      topN: options.similarity?.topN
+    });
+    this.graphService = new GraphService(dir, this.postStore);
+    this.tagIndex = new TagIndex(allPosts);
+    this.mediaStore = new MediaStore(dir);
+    this.issueReport = loadJsonFile(join(dir, "processor-issues.json"), {
+      issues: [],
+      summary: { totalIssues: 0, errorCount: 0, warningCount: 0, infoCount: 0, filesAffected: 0, categoryCounts: {}, moduleCounts: {} },
+      metadata: { processStartTime: "", processEndTime: "" }
+    });
+    this.issueIndex = new IssueIndex(this.issueReport);
+    const postStore = this.postStore;
+    const tagIdx = this.tagIndex;
+    const mediaStr = this.mediaStore;
+    const mapPost = this.mapPostFn;
+    const mp = mapPost ?? ((post) => post);
+    this.posts = {
+      list: () => postStore.list().map(mp),
+      get: (slug) => mp(postStore.get(slug)),
+      getByHash: (hash) => mp(postStore.getByHash(hash)),
+      getByPath: (path) => mp(postStore.getByPath(path)),
+      recent: (count) => postStore.recent(count).map(mp),
+      filter: (predicate) => postStore.list().map(mp).filter(predicate),
+      where: (query) => postStore.where(query).map(mp),
+      featured: () => postStore.featured().map(mp),
+      published: () => postStore.published().map(mp),
+      sorted: (posts) => {
+        if (posts) {
+          return [...posts].sort(
+            (a, b) => comparePostsFeaturedDate(a, b)
+          );
+        }
+        return postStore.sorted().map(mp);
+      },
+      slugs: () => postStore.slugs(),
+      get count() {
+        return postStore.count;
+      },
+      get slugMap() {
+        return postStore.slugMap;
+      }
+    };
+    this.tags = {
+      list: () => tagIdx.listTags(),
+      posts: (tag) => tagIdx.postsByTag(tag).map(mp)
+    };
+    this.categories = {
+      list: () => tagIdx.listCategories(),
+      posts: (category) => tagIdx.postsByCategory(category).map(mp)
+    };
+    this.media = {
+      list: () => mediaStr.list(),
+      get: (path) => mediaStr.get(path)
+    };
+    if (this.debug) {
+      console.log(`[folderblog/local] Search: ${searchEnabled ? "enabled" : "disabled"}`);
+      console.log(`[folderblog/local] Similarity: ${this.similarityService.available ? "available" : "unavailable"}`);
+      console.log(`[folderblog/local] Graph: ${this.graphService.available ? "available" : "unavailable"}`);
+      console.log(`[folderblog/local] Tags: ${this.tagIndex.tagCount}, Categories: ${this.tagIndex.categoryCount}`);
+      console.log(`[folderblog/local] Media: ${this.mediaStore.count}`);
+    }
+  }
+  search(query, options) {
+    if (!this.searchEngine) return [];
+    return this.searchEngine.search(query, options);
+  }
+  searchAutocomplete(term, limit) {
+    if (!this.searchEngine) return [];
+    return this.searchEngine.autoSuggest(term, limit);
+  }
+  similar(slugOrHash, count) {
+    return this.similarityService.getSimilar(slugOrHash, count);
+  }
+  related(slugOrHash, count) {
+    return this.graphService.getRelated(
+      slugOrHash,
+      count,
+      (s, c) => this.similar(s, c)
+    );
+  }
+  // Namespace objects — initialized in constructor
+  posts;
+  tags;
+  categories;
+  media;
+  // --- Stats ---
+  get stats() {
+    return {
+      posts: this.postStore.count,
+      media: this.mediaStore.count,
+      tags: this.tagIndex.tagCount,
+      categories: this.tagIndex.categoryCount,
+      hasSearch: this.searchEngine !== null,
+      hasSimilarity: this.similarityService.available
+    };
+  }
+  // --- Issues ---
+  get issues() {
+    return this.issueReport;
+  }
+  get report() {
+    return this.issueIndex;
+  }
+};
+function createLocalClient(options) {
+  return new FolderBlogLocal(options);
+}
+
+export { IssueIndex, createLocalClient, extractSection, isDraft, isHidden, isPublished, isScheduled, toPost };