content/blog-data.ts:    let _posts: BlogPost[] = [];    // 模块级变量
i18n/i18n-data.ts:       let _options: LessI18nOptions;  // 模块级变量

Before (stateful):
  @openelement/content:  initBlogData() → _posts       (module state, needs bridge)
                    getPosts()     → _posts          (reads state)
  adapter-vite:     inject initBlogData() into entry (ad-hoc bridge)
  route component:  import { getPosts } from '@openelement/content'
  问题：_posts 在两个模块空间各一份 → 需要桥

After (stateless):
  @openelement/content:  loadBlogData(dir) → BlogPost[]  (pure function, zero state)
  adapter-vite:     virtual:less-blog-data           (resolveId + load)
                    load() calls loadBlogData() → generates export code
  route component:  import { posts, getPostBySlug } from 'virtual:less-blog-data'
  零桥，零状态，零双路径

Phase 0: @deno/vite-plugin → 独立，可先行
Phase 1: content 纯函数拆分 → Phase 2 的前置
Phase 2: adapter-vite 虚拟数据模块 → Phase 1 + Phase 3 的核心
Phase 3: content HMR → Phase 2 的后续
Phase 4: i18n 同模式改造 → Phase 2 的验证
Phase 5: 静态内容页 → Phase 2 的扩展

cd my-tech-blog && deno task dev
# 访问 http://localhost:5173 → 页面正常渲染
# 确认 vite.config.ts 无 resolve.alias

sequenceDiagram
    participant User as vite.config.ts
    participant Deno as @deno/vite-plugin
    participant Vite as Vite Dev Server
    participant FS as Deno Workspace FS

    User->>Vite: plugins: [lessjs()]
    Note over User: Zero resolve.alias
    Vite->>Deno: resolveId('@openelement/content')
    Deno->>FS: import.meta.resolve('@openelement/content')
    FS-->>Deno: file:///.../packages/content/src/index.ts
    Deno-->>Vite: resolved path
    Vite->>Deno: resolveId('@openelement/core/ssr-handler')
    Deno->>FS: import.meta.resolve('@openelement/core/ssr-handler')
    FS-->>Deno: file:///.../packages/core/src/ssr-handler.ts
    Deno-->>Vite: resolved path

// packages/content/src/blog/blog-data.ts

/**
 * Pure function: load blog data from file system.
 * No module-level state. No side effects beyond reading files.
 * Can be called from any runtime context.
 *
 * This replaces the stateful initBlogData() + getPosts() pattern.
 * For virtual module consumers, use virtual:less-blog-data instead.
 */
export async function loadBlogData(options?: LessBlogOptions): Promise<{
  posts: BlogPost[];
  basePath: string;
}> {
  const routes = await generateBlogRoutes(options);
  return {
    posts: routes.posts,
    basePath: routes.basePath,
  };
}

// 全部删除 — 不向后兼容
// let _posts: BlogPost[] = [];           ← 删除
// let _options: LessBlogOptions = {};    ← 删除
// export function initBlogData() {}      ← 删除
// export function getPosts() {}          ← 删除
// export function getPostBySlug() {}     ← 删除
// export function getBlogOptions() {}    ← 删除

// packages/content/src/blog/blog-data.ts — 重写后

import type { BlogPost, LessBlogOptions } from './types.ts';
import { generateBlogRoutes } from './routes.ts';

/**
 * Pure function: load blog data from file system.
 * No module-level state. No side effects beyond reading files.
 * Can be called from any runtime context.
 */
export async function loadBlogData(options?: LessBlogOptions): Promise<{
  posts: BlogPost[];
  basePath: string;
}> {
  const routes = await generateBlogRoutes(options);
  return {
    posts: routes.posts,
    basePath: routes.basePath,
  };
}

cd packages/content && deno test
# loadBlogData() 单元测试通过
# initBlogData/getPosts/getPostBySlug/getBlogOptions 已删除，不再存在

sequenceDiagram
    participant Dev as Developer
    participant Content as @openelement/content
    participant FS as File System

    Note over Dev: Phase 1: Pure function only
    Dev->>Content: loadBlogData(opts)
    Content->>FS: read markdown files
    FS-->>Content: raw content
    Content->>Content: parse + sort
    Content-->>Dev: { posts, basePath }
    Note over Content: Zero module state

/**
 * @openelement/adapter-vite - Virtual data module plugins
 *
 * Replaces module-level state in @openelement/content and @openelement/i18n
 * with virtual module data exports. The load() hook runs in the
 * Vite plugin process and generates code that executes in the
 * SSR runner — this IS the data bridge.
 *
 * Dev mode:  ssrLoadModule('virtual:less-blog-data') → load() → fresh data
 * Build mode: viteBuild bundles the virtual module → data inlined
 * HMR:       invalidateModule → load() re-runs → fresh data
 *
 * Zero module state. Zero init functions. Zero dual paths.
 */

import type { Plugin } from 'vite';
import type { LessBuildContext } from './build-context.js';
import { loadBlogData } from '@openelement/content/blog-data';
import type { LessBlogOptions } from '@openelement/content/types';

// ─── Virtual module IDs ────────────────────────────────────────

const VIRTUAL_BLOG_DATA_ID = 'virtual:less-blog-data';
const RESOLVED_BLOG_DATA_ID = '\0' + VIRTUAL_BLOG_DATA_ID;

// ─── Blog data virtual module ──────────────────────────────────

export function createBlogDataPlugin(ctx: LessBuildContext): Plugin {
  return {
    name: 'less:blog-data',
    enforce: 'pre',

    resolveId(id) {
      if (id === VIRTUAL_BLOG_DATA_ID) return RESOLVED_BLOG_DATA_ID;
    },

    async load(id) {
      if (id !== RESOLVED_BLOG_DATA_ID) return;

      const blogOpts = ctx.blogOptions;
      if (!blogOpts) {
        // Blog not configured — export empty data
        return [
          'export const posts = [];',
          'export function getPostBySlug(slug) { return undefined; }',
          'export function getBlogOptions() { return {}; }',
        ].join('\n');
      }

      const options: LessBlogOptions = {
        contentDir: blogOpts.contentDir,
        basePath: blogOpts.basePath,
      };

      const { posts } = await loadBlogData(options);

      // Generate code that exports data + derived functions
      // The posts array is serialized as JSON — this is the bridge.
      // In build mode, this gets inlined into the SSR bundle.
      // In dev mode, this runs fresh on each ssrLoadModule() call.
      return [
        `const _posts = ${JSON.stringify(posts)};`,
        '',
        `/** All published blog posts, sorted newest first */`,
        `export const posts = _posts;`,
        '',
        `/** Get a single post by slug */`,
        `export function getPostBySlug(slug) {`,
        `  return _posts.find(p => p.slug === slug);`,
        `}`,
        '',
        `/** Get blog configuration */`,
        `export function getBlogOptions() {`,
        `  return ${JSON.stringify(options)};`,
        `}`,
      ].join('\n');
    },
  };
}

-  // --- Dev mode: Initialize blog data ---
-  // In SSG mode, initBlogData() is called by build-ssg.ts after importing
-  // the SSR bundle (same module instance). In dev mode, the Vite SSR runner
-  // loads route components (e.g., cyber-home) that call getPosts(), but the
-  // blog-data module's _posts variable is empty because initBlogData() only
-  // ran in the plugin process (different module space). We must call
-  // initBlogData() inside the virtual entry so it runs in the same module
-  // instance as the route components.
-  if (!desc.isSSG && desc.blog) {
-    lines.push('// Dev mode: Initialize blog data in SSR runner module space');
-    lines.push('try {');
-    lines.push("  const { initBlogData } = await import('@openelement/content');");
-    lines.push(`  await initBlogData(${JSON.stringify(desc.blog)});`);
-    lines.push('} catch { /* @openelement/content not available */ }');
-    lines.push('');
-  }

  export interface EntryDescriptor {
    // ...
-   /** Blog options for dev-mode initBlogData() call */
-   blog?: { contentDir?: string; basePath?: string } | null;
  }

- export { initBlogData, getPosts, getPostBySlug, getBlogOptions } from "@openelement/content"
+ export { posts, getPostBySlug, getBlogOptions } from "virtual:less-blog-data"

  // In the generated SSR bundle
  export async function getStaticPaths(routePath) {
    // ...
    if (routePath === '/blog/:slug') {
-     const { getPosts } = await import('@openelement/content');
-     return getPosts().map(p => ({ slug: p.slug }));
+     return posts.map(p => ({ slug: p.slug }));
    }
  }

  // my-tech-blog/app/routes/blog/[slug].ts
- import { getPostBySlug } from '@openelement/content';
+ import { getPostBySlug } from 'virtual:less-blog-data';

// packages/adapter-vite/src/virtual-data.d.ts
declare module 'virtual:less-blog-data' {
  import type { BlogPost, LessBlogOptions } from '@openelement/content';
  export const posts: BlogPost[];
  export function getPostBySlug(slug: string): BlogPost | undefined;
  export function getBlogOptions(): LessBlogOptions;
}

# Dev 模式
cd my-tech-blog && deno task dev
# 访问 http://localhost:5173 → 博客首页显示文章列表
# 访问 http://localhost:5173/blog/some-post → 文章内容正常

# Build 模式
cd my-tech-blog && deno task build
# dist/ 目录生成完整 SSG HTML
# 博客文章页面内容正确

sequenceDiagram
    participant Browser
    participant HonoVite as @hono/vite-dev-server
    participant Vite as Vite SSR Runner
    participant Plugin as less:blog-data (load)
    participant Content as @openelement/content
    participant FS as File System

    Browser->>HonoVite: GET /blog
    HonoVite->>Vite: ssrLoadModule('virtual:less-hono-entry')
    Vite->>Vite: ssrLoadModule('virtual:less-blog-data')
    Vite->>Plugin: load('\0virtual:open-blog-data')
    Plugin->>Content: loadBlogData(opts)
    Content->>FS: read markdown files
    FS-->>Content: raw content
    Content->>Content: parse + sort
    Content-->>Plugin: { posts: [3 items] }
    Plugin-->>Vite: "const _posts = [...]; export const posts = _posts; ..."
    Vite->>Vite: execute virtual module code
    Note over Vite: posts = [3 items] in SSR runner
    Vite-->>HonoVite: app module loaded
    HonoVite->>Vite: route component imports from virtual:less-blog-data
    Vite-->>HonoVite: posts (already loaded)
    HonoVite-->>Browser: HTML with blog posts

sequenceDiagram
    participant CLI as deno task build
    participant Vite as viteBuild(ssr:true)
    participant Plugin as less:blog-data (load)
    participant Content as @openelement/content
    participant FS as File System

    CLI->>Vite: start SSR build
    Vite->>Plugin: load('\0virtual:open-blog-data')
    Plugin->>Content: loadBlogData(opts)
    Content->>FS: read markdown files
    FS-->>Content: raw content
    Content-->>Plugin: { posts: [3 items] }
    Plugin-->>Vite: virtual module code with inlined data
    Note over Vite: noExternal → virtual module inlined into bundle
    Vite-->>CLI: self-contained SSR bundle
    CLI->>CLI: import bundle, iterate routes
    CLI->>CLI: renderRoute('/blog/hello') → HTML
    CLI->>CLI: write dist/blog/hello/index.html

// packages/content/src/index.ts — 添加到 contentPlugin

configureServer(server) {
  const contentDir = blogOpts?.contentDir;
  if (!contentDir) return;

  const absoluteContentDir = resolve(server.config.root, contentDir);

  // Watch the content directory for changes
  server.watcher.add(absoluteContentDir);

  const invalidateBlogData = (file: string) => {
    if (!file.startsWith(absoluteContentDir)) return;
    if (!file.endsWith('.md') && !file.endsWith('.mdx')) return;

    // Invalidate the virtual blog data module
    const mod = server.moduleGraph.getModuleById(RESOLVED_BLOG_DATA_ID);
    if (mod) {
      server.moduleGraph.invalidateModule(mod);
      log.info(`Content changed: ${relative(server.config.root, file)} — reloading`);
      server.hot.send({ type: 'full-reload' });
    }
  };

  server.watcher.on('change', invalidateBlogData);
  server.watcher.on('add', invalidateBlogData);
  server.watcher.on('unlink', invalidateBlogData);
},

cd my-tech-blog && deno task dev
# 1. 访问 http://localhost:5173 → 博客正常
# 2. 编辑 content/blog/some-post.md → 修改标题
# 3. 刷新浏览器 → 看到新标题（无需重启 dev server）
# 4. 新增 content/blog/new-post.md
# 5. 刷新浏览器 → 新文章出现在列表中

sequenceDiagram
    participant Dev as Developer
    participant Watcher as Vite Watcher
    participant Graph as Module Graph
    participant Vite as Vite SSR Runner
    participant Plugin as less:blog-data (load)
    participant Browser

    Dev->>Watcher: edit content/blog/post.md
    Watcher->>Graph: invalidateModule(virtual:less-blog-data)
    Graph-->>Watcher: module invalidated
    Watcher->>Browser: hot.send({ type: 'full-reload' })
    Browser->>Vite: GET /blog (new request)
    Vite->>Plugin: load('\0virtual:open-blog-data')
    Note over Plugin: load() re-reads all .md files
    Plugin-->>Vite: fresh data exports
    Vite-->>Browser: HTML with updated content

// virtual:less-i18n-data
const VIRTUAL_I18N_DATA_ID = 'virtual:less-i18n-data';
const RESOLVED_I18N_DATA_ID = '\0' + VIRTUAL_I18N_DATA_ID;

export function createI18nDataPlugin(ctx: LessBuildContext): Plugin {
  return {
    name: 'less:i18n-data',
    enforce: 'pre',

    resolveId(id) {
      if (id === VIRTUAL_I18N_DATA_ID) return RESOLVED_I18N_DATA_ID;
    },

    load(id) {
      if (id !== RESOLVED_I18N_DATA_ID) return;

      const i18nOpts = ctx.i18nOptions;
      if (!i18nOpts) {
        return [
          'export const locales = [];',
          'export function getDefaultLocale() { return "en"; }',
          'export function getI18nOptions() { return null; }',
        ].join('\n');
      }

      return [
        `const _options = ${JSON.stringify(i18nOpts)};`,
        'export const locales = _options.locales;',
        'export function getDefaultLocale() { return _options.defaultLocale || "en"; }',
        'export function getI18nOptions() { return _options; }',
      ].join('\n');
    },
  };
}

declare module 'virtual:less-i18n-data' {
  import type { LessI18nOptions } from '@openelement/i18n';
  export const locales: string[];
  export function getDefaultLocale(): string;
  export function getI18nOptions(): LessI18nOptions | null;
}

# 使用 i18n 的项目（如有）
deno task dev
# 访问页面 → locale 切换正常
# 无 i18n 的项目 → 编译不报错（虚拟模块返回空数据）

// types.ts
export interface LessPagesOptions {
  /** Map of page key → content file path (relative to project root) */
  [key: string]: string;
  // e.g., { about: 'content/about/index.md', credits: 'content/credits.md' }
}

export interface LessContentOptions {
  blog?: LessBlogOptions | false;
  nav?: LessNavOptions | false;
  sitemap?: SitemapOptions | false;
  pages?: LessPagesOptions;  // NEW
  ctx?: LessBuildContext;
}

// virtual:less-page-data
// load() generates:
const _pages = {
  about: { title: "About", html: "<p>...</p>", frontmatter: {...} },
  credits: { title: "Credits", html: "<p>...</p>", frontmatter: {...} },
};
export function getPage(key) { return _pages[key]; }
export const pageKeys = Object.keys(_pages);

// app/routes/about.ts
import { getPage } from 'virtual:less-page-data';

export default class AboutPage extends LitElement {
  connectedCallback() {
    super.connectedCallback();
    const page = getPage('about');
    this.innerHTML = page.html;
  }
}

# my-tech-blog About 页面
# 1. 创建 content/about/index.md
# 2. 配置 lessContent({ pages: { about: 'content/about/index.md' } })
# 3. 路由组件 import { getPage } from 'virtual:less-page-data'
# 4. 访问 /about → 渲染 markdown 内容
# 5. 无 node:fs 依赖