@riebeckite/honox 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 export { loadRiebeckiteConfig, resolveHonoxConfig, } from "./src/config_loader.js";
+export { replaceHonoxIslandDependencyPlugin } from "./src/honox_islands.js";
+export type { ScaffoldSiteOptions, ScaffoldSiteResult, } from "./src/scaffold/index.js";
+export { ScaffoldSiteError, scaffoldRiebeckiteSite, } from "./src/scaffold/index.js";
 export { createRiebeckiteSsg, defaultSsgEntry, riebeckiteSsgExtensionMap, } from "./src/ssg.js";
 export type { RiebeckiteSsgOptions } from "./src/ssg_plugin.js";
 export { riebeckiteSsg } from "./src/ssg_plugin.js";
 export type { RiebeckiteIntegrationOptions, RiebeckiteViteOptions, } from "./src/vite_plugin.js";
 export { defaultSsrExternals, riebeckite, riebeckiteVite, } from "./src/vite_plugin.js";
-export type { ScaffoldSiteOptions, ScaffoldSiteResult, } from "./src/scaffold/index.js";
-export { ScaffoldSiteError, scaffoldRiebeckiteSite, } from "./src/scaffold/index.js";
 export type { ResolvedHonoxApplication, ResolveHonoxApplicationOptions, } from "./src/vite_runner.js";
 export { buildHonoxApplication, resolveHonoxApplication, resolveHonoxApplicationRoot, startHonoxDevServer, } from "./src/vite_runner.js";

package/dist/index.js

@@ -154,480 +154,162 @@ function pathToFileUrl(filePath) {
   return `file:///${filePath.replace(/\\/g, "/").replace(/^([A-Za-z]):/, "$1:")}`;
 }
 
-// src/ssg_plugin.ts
-import { defaultExtensionMap, toSSG } from "hono/ssg";
-import { relative } from "node:path";
-import { createServer } from "vite";
-var defaultEntry = "./src/index.tsx";
-function riebeckiteSsg(options = {}) {
-  const virtualId = "virtual:riebeckite-ssg-void-entry";
-  const resolvedVirtualId = `\0${virtualId}`;
-  const entry = options.entry ?? defaultEntry;
-  let resolvedConfig;
+// src/honox_islands.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+import { parse } from "@babel/parser";
+var honoxIslandDependencyPluginName = "inject-importing-islands";
+var importingIslandsExport = "__importing_islands";
+function replaceHonoxIslandDependencyPlugin(plugins) {
+  return [
+    ...plugins.map(disableHonoxIslandDependencyPlugin),
+    scopedIslandDependencyPlugin()
+  ];
+}
+function disableHonoxIslandDependencyPlugin(plugin) {
+  if (plugin instanceof Promise) {
+    return plugin.then(disableHonoxIslandDependencyPlugin);
+  }
+  if (plugin.name !== honoxIslandDependencyPluginName) return plugin;
+  return { ...plugin, transform: void 0 };
+}
+function scopedIslandDependencyPlugin() {
+  let appDirectory = "";
+  let islandDirectory = "";
   return {
-    name: "riebeckite-ssg",
-    apply: "build",
-    enforce: "post",
-    config() {
-      return {
-        build: {
-          rollupOptions: {
-            input: [virtualId]
-          }
-        }
-      };
-    },
+    name: "riebeckite-inject-importing-islands",
     configResolved(config) {
-      resolvedConfig = config;
-    },
-    resolveId(id) {
-      return id === virtualId ? resolvedVirtualId : void 0;
+      appDirectory = path3.resolve(config.root, "app");
+      islandDirectory = path3.join(appDirectory, "islands");
     },
-    load(id) {
-      return id === resolvedVirtualId ? 'console.log("suppress empty chunk message")' : void 0;
-    },
-    async generateBundle(_outputOptions, bundle) {
-      const config = resolvedConfig;
-      if (!config) {
-        throw new Error("Riebeckite SSG could not resolve the Vite configuration.");
-      }
-      removeVirtualEntryChunk(bundle, resolvedVirtualId);
-      const server2 = await createServer({
-        root: config.root,
-        define: config.define,
-        resolve: {
-          ...config.resolve,
-          builtins: [...config.resolve.builtins, /^node:/]
-        },
-        plugins: [],
-        build: { ssr: true },
-        mode: config.mode
-      });
-      try {
-        const module = await server2.ssrLoadModule(entry);
-        const app = module.default;
-        if (!app) {
-          throw new Error(`Failed to find a default export from ${entry}.`);
-        }
-        const generatedHtml = [];
-        const result = await toSSG(
-          app,
-          {
-            writeFile: async (filePath, data) => {
-              const fileName = relative(config.build.outDir, filePath).replaceAll(
-                "\\",
-                "/"
-              );
-              if (fileName.endsWith(".html") && typeof data === "string") {
-                generatedHtml.push({ path: fileName, html: data });
-              }
-              this.emitFile({
-                type: "asset",
-                fileName,
-                source: data
-              });
-            },
-            async mkdir() {
-            }
-          },
-          {
-            dir: config.build.outDir,
-            plugins: options.plugins ?? [],
-            extensionMap: options.extensionMap ?? defaultExtensionMap
-          }
-        );
-        if (!result.success) throw result.error;
-        await emitGeneratedOutputs(
-          module,
-          (asset) => this.emitFile(asset)
-        );
-        inspectGeneratedHtmlPages(module, generatedHtml, {
-          warn: (message) => this.warn(message),
-          info: (message) => this.info(message)
-        });
-      } finally {
-        await server2.close();
+    async transform(sourceCode, id) {
+      const modulePath = toFilePath(id);
+      if (!isInDirectory(modulePath, appDirectory) || !isJavaScriptModule(modulePath)) {
+        return;
       }
+      if (!await importsIsland(modulePath, sourceCode, this)) return;
+      return {
+        code: `${sourceCode}
+export const ${importingIslandsExport} = true;
+`,
+        map: null
+      };
     }
   };
-}
-async function emitGeneratedOutputs(module, emit) {
-  const content = module.content;
-  if (!content) return;
-  const manifest = await content.getManifest();
-  for (const output of manifest.generatedOutputs ?? []) {
-    emit({
-      type: "asset",
-      fileName: output.path,
-      source: output.content
-    });
-  }
-}
-function inspectGeneratedHtmlPages(module, pages, log) {
-  const plugins = module.config?.plugins ?? [];
-  for (const plugin of plugins) {
-    const inspector = plugin.inspectGeneratedHtml;
-    if (typeof inspector !== "function") continue;
-    for (const page of pages) {
-      for (const diagnostic of inspector(page) ?? []) {
-        const label = `[${plugin.name ?? "plugin"}] ${page.path}: ${diagnostic.message}`;
-        if (diagnostic.severity === "info") log.info(label);
-        else log.warn(label);
+  async function importsIsland(modulePath, sourceCode, pluginContext) {
+    const visited = /* @__PURE__ */ new Set();
+    const visit = async (currentModulePath, currentSourceCode) => {
+      if (visited.has(currentModulePath)) return false;
+      visited.add(currentModulePath);
+      if (isInDirectory(currentModulePath, islandDirectory)) return true;
+      const importSources = getStaticImportSources(currentSourceCode);
+      for (const importSource of importSources) {
+        const resolved = await pluginContext.resolve(
+          importSource,
+          currentModulePath
+        );
+        if (!resolved) continue;
+        const dependencyPath = toFilePath(resolved.id);
+        if (!isInDirectory(dependencyPath, appDirectory) || !isJavaScriptModule(dependencyPath)) {
+          continue;
+        }
+        try {
+          const dependencySourceCode = await fs3.readFile(
+            dependencyPath,
+            "utf8"
+          );
+          if (await visit(dependencyPath, dependencySourceCode)) return true;
+        } catch {
+        }
       }
-    }
+      return false;
+    };
+    return visit(modulePath, sourceCode);
   }
 }
-function removeVirtualEntryChunk(bundle, virtualEntryId) {
-  for (const chunk of Object.values(bundle)) {
-    if (chunk.type === "chunk" && chunk.moduleIds?.includes(virtualEntryId)) {
-      delete bundle[chunk.fileName];
+function getStaticImportSources(sourceCode) {
+  const ast = parse(sourceCode, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"]
+  });
+  return ast.program.body.flatMap((statement) => {
+    if (statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") {
+      return statement.source ? [statement.source.value] : [];
     }
-  }
+    return [];
+  });
 }
-
-// src/ssg.ts
-var defaultSsgEntry = "./app/server.ts";
-function riebeckiteSsgExtensionMap() {
-  return {
-    "application/atom+xml": "xml",
-    "application/json": "json",
-    "application/rss+xml": "xml",
-    "application/xml": "xml",
-    "text/html": "html",
-    "text/plain": "txt",
-    "text/xml": "xml"
-  };
+function toFilePath(id) {
+  return id.split("?", 1)[0] ?? id;
 }
-function createRiebeckiteSsg(options = {}) {
-  return riebeckiteSsg({
-    ...options,
-    entry: options.entry ?? defaultSsgEntry,
-    extensionMap: {
-      ...riebeckiteSsgExtensionMap(),
-      ...options.extensionMap
-    }
-  });
+function isInDirectory(filePath, directory) {
+  const relativePath = path3.relative(directory, filePath);
+  return relativePath !== "" && !relativePath.startsWith(`..${path3.sep}`) && !path3.isAbsolute(relativePath);
+}
+function isJavaScriptModule(filePath) {
+  return /\.[cm]?[jt]sx?$/.test(filePath);
 }
 
-// src/vite_plugin.ts
-import path5 from "node:path";
+// src/scaffold/index.ts
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
 
-// src/asset_entries.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-import { uniqueStrings } from "@riebeckite/core";
-function writeRiebeckiteAssetEntries(config, paths2) {
-  writeGeneratedFile(paths2.pluginStyles, createPluginStylesEntry(config));
-  writeGeneratedFile(paths2.themeStyles, createThemeStylesEntry(config));
+// src/scaffold/localized-content.ts
+var SCAFFOLD_LANGUAGES = [
+  "en",
+  "ja",
+  "zh-CN",
+  "es",
+  "de",
+  "fr",
+  "ko"
+];
+function defaultLanguageForLocale(locale) {
+  const normalized = locale.toLowerCase();
+  if (normalized.startsWith("ja")) return "ja";
+  if (normalized.startsWith("zh")) return "zh-CN";
+  if (normalized.startsWith("es")) return "es";
+  if (normalized.startsWith("de")) return "de";
+  if (normalized.startsWith("fr")) return "fr";
+  if (normalized.startsWith("ko")) return "ko";
+  return "en";
 }
-function createPluginStylesEntry(config) {
-  return createStylesheetEntry(
-    collectPluginStyleSpecifiers(config),
-    "Plugin default styles, in resolved plugin order. Generated by @riebeckite/honox; do not edit. Import this before the theme stylesheet so a theme can override plugin defaults."
-  );
+var HELPERS = {
+  en: "https://github.com/Rerurate514/riebeckite/blob/main/docs/en/README.md",
+  ja: "https://github.com/Rerurate514/riebeckite/blob/main/docs/ja/README.md"
+};
+var PLUGIN_INDEX_URL = "https://github.com/Rerurate514/riebeckite/tree/main/packages/plugins";
+var THEMES_INDEX_URL = "https://github.com/Rerurate514/riebeckite/tree/main/packages/themes";
+function pluginReadmeUrl(slug) {
+  return `https://github.com/Rerurate514/riebeckite/blob/main/packages/plugins/${slug}/README.md`;
 }
-function createThemeStylesEntry(config) {
-  return createStylesheetEntry(
-    config.theme.styles.map((style2) => style2.moduleSpecifier),
-    "Theme styles. Generated by @riebeckite/honox; do not edit. Import this after the plugin stylesheet so the theme wins the plugin/theme cascade."
-  );
+function themeReadmeUrl(slug) {
+  return `https://github.com/Rerurate514/riebeckite/blob/main/packages/themes/${slug}/README.md`;
 }
-function collectPluginStyleSpecifiers(config) {
-  return config.plugins.flatMap(
-    (plugin) => (plugin.assets ?? []).filter((asset) => asset.kind === "style").map((asset) => asset.moduleSpecifier)
-  );
+function localizedContentFiles(variables) {
+  const defaultLang = defaultLanguageForLocale(variables.locale);
+  const pages = [
+    { basePath: "index", build: (language) => indexContent(variables, language) },
+    { basePath: "framework/plugins", build: (language) => pluginsContent(language) },
+    { basePath: "framework/themes", build: (language) => themesContent(language) }
+  ];
+  const files = [];
+  for (const page of pages) {
+    for (const language of SCAFFOLD_LANGUAGES) {
+      const suffix = language === defaultLang ? "" : `.${language}`;
+      files.push({
+        path: `content/${page.basePath}${suffix}.md`,
+        content: page.build(language)
+      });
+    }
+  }
+  return files;
 }
-function createStylesheetEntry(moduleSpecifiers, banner) {
-  const imports = uniqueStrings(moduleSpecifiers).map((specifier) => `@import ${JSON.stringify(specifier)};`).join("\n");
-  if (!banner) return imports;
-  const header = `/* ${banner.replace(/\*\//g, "* /")} */`;
-  return imports ? `${header}
-${imports}
-` : `${header}
-`;
+function read(text, language) {
+  return text[language];
 }
-function writeGeneratedFile(filePath, contents) {
-  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
-  fs3.writeFileSync(filePath, contents);
-}
-
-// src/client_module.ts
-var clientModuleId = "virtual:riebeckite/client";
-var resolvedClientModuleId = `\0${clientModuleId}`;
-function riebeckiteClientModule(getConfig) {
-  return {
-    name: "riebeckite-client-module",
-    resolveId(id) {
-      if (id === clientModuleId) return resolvedClientModuleId;
-      return null;
-    },
-    load(id) {
-      if (id !== resolvedClientModuleId) return null;
-      return createClientModule(getConfig());
-    }
-  };
-}
-function createClientModule(config) {
-  const imports = [];
-  const initializers = [];
-  for (const [index, entry] of config.plugins.flatMap((plugin) => plugin.clientEntries ?? []).entries()) {
-    const localName = `pluginClientInitializer${index}`;
-    const importTarget = entry.exportName ? `{ ${entry.exportName} as ${localName} }` : localName;
-    imports.push(
-      `import ${importTarget} from ${JSON.stringify(entry.moduleSpecifier)};`
-    );
-    initializers.push(localName);
-  }
-  return `${imports.join("\n")}
-
-export function initRiebeckiteClient() {
-${initializers.map((name) => `  ${name}();`).join("\n")}
-}
-`;
-}
-
-// src/vite_runner.ts
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
-import { build, createServer as createServer2 } from "vite";
-var viteConfigFileNames = [
-  "vite.config.ts",
-  "vite.config.js",
-  "vite.config.mjs"
-];
-async function resolveHonoxApplicationRoot(configRoot) {
-  const roots = await findViteApplicationRoots(configRoot);
-  if (roots.length === 1) return roots[0];
-  if (roots.length === 0) {
-    throw new HonoxApplicationRootError(
-      `Could not find a Vite application under ${configRoot}.`
-    );
-  }
-  throw new HonoxApplicationRootError(
-    `Found multiple Vite applications under ${configRoot}: ${roots.join(", ")}.`
-  );
-}
-var HonoxApplicationRootError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "HonoxApplicationRootError";
-  }
-};
-async function resolveHonoxApplication(options) {
-  const configRoot = path4.resolve(options.configRoot);
-  const appRoot = options.appRoot ? path4.resolve(options.appRoot) : await resolveHonoxApplicationRoot(configRoot);
-  const workspaceRoot = options.workspaceRoot ?? await findWorkspaceRoot(configRoot);
-  const rawConfig = await loadRiebeckiteConfig({
-    configRoot,
-    configFile: options.configFile,
-    workspaceRoot
-  });
-  const config = resolveHonoxConfig(rawConfig, appRoot);
-  return {
-    config,
-    configRoot,
-    appRoot,
-    contentRoot: config.content.directory
-  };
-}
-async function findWorkspaceRoot(configRoot) {
-  try {
-    const workspaceConfig = path4.join(configRoot, "pnpm-workspace.yaml");
-    return (await fs4.stat(workspaceConfig)).isFile() ? configRoot : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function startHonoxDevServer(options) {
-  const server2 = await createServer2({ root: options.root });
-  await server2.listen();
-  server2.printUrls();
-  await waitForShutdown(server2);
-}
-async function buildHonoxApplication(options) {
-  await runTraced(
-    options.tracer,
-    "integration.honox.client_build",
-    () => build({ root: options.root, mode: "client" })
-  );
-  await runTraced(
-    options.tracer,
-    "integration.honox.server_build",
-    () => build({ root: options.root })
-  );
-}
-async function runTraced(tracer, name, buildTask) {
-  return tracer ? await tracer.span(name, {}, buildTask) : await buildTask();
-}
-async function waitForShutdown(server2) {
-  await new Promise((resolve) => {
-    const close = () => {
-      void server2.close().finally(resolve);
-    };
-    process.once("SIGINT", close);
-    process.once("SIGTERM", close);
-  });
-}
-async function findViteApplicationRoots(root) {
-  const directories = [root];
-  const applicationRoots = [];
-  while (directories.length > 0) {
-    const directory = directories.pop();
-    if (!directory) continue;
-    if (await hasViteConfig(directory)) applicationRoots.push(directory);
-    const entries = await fs4.readdir(directory, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git" || entry.name === "tests") {
-        continue;
-      }
-      directories.push(path4.join(directory, entry.name));
-    }
-  }
-  return applicationRoots;
-}
-async function hasViteConfig(directory) {
-  for (const fileName of viteConfigFileNames) {
-    try {
-      if ((await fs4.stat(path4.join(directory, fileName))).isFile()) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-
-// src/vite_plugin.ts
-var defaultSsrExternals = [
-  "extend",
-  "debug",
-  "node:fs/promises",
-  "node:path",
-  "parse-numeric-range",
-  "slugify",
-  "vfile-matter"
-];
-function riebeckite(options = {}) {
-  let resolvedConfig;
-  const getConfig = () => {
-    if (!resolvedConfig) {
-      throw new Error("Riebeckite config has not been loaded yet.");
-    }
-    return resolvedConfig;
-  };
-  return [
-    {
-      name: "riebeckite-host-integration",
-      async config(userConfig) {
-        const root = userConfig.root ? path5.resolve(userConfig.root) : process.cwd();
-        const appRoot = options.appRoot ?? root;
-        const application = await resolveHonoxApplication({
-          configRoot: options.configRoot ?? appRoot,
-          configFile: options.configFile,
-          appRoot,
-          workspaceRoot: options.workspaceRoot
-        });
-        resolvedConfig = application.config;
-        writeRiebeckiteAssetEntries(resolvedConfig, {
-          pluginStyles: path5.join(appRoot, "app/.riebeckite/plugin-styles.css"),
-          themeStyles: path5.join(appRoot, "app/.riebeckite/theme-styles.css")
-        });
-        return {
-          define: {
-            "process.env.RIEBECKITE_APP_ROOT": JSON.stringify(appRoot)
-          },
-          resolve: {
-            alias: options.workspaceRoot ? createWorkspacePackageAliases(options.workspaceRoot) : []
-          }
-        };
-      }
-    },
-    riebeckiteClientModule(getConfig)
-  ];
-}
-function riebeckiteVite(options = {}) {
-  const { ssg, ssrExternals, ...integration } = options;
-  return [
-    ...riebeckite(integration),
-    riebeckiteSsrExternals([...defaultSsrExternals, ...ssrExternals ?? []]),
-    createRiebeckiteSsg(ssg)
-  ];
-}
-function riebeckiteSsrExternals(externals) {
-  return {
-    name: "riebeckite-ssr-externals",
-    config() {
-      return {
-        environments: {
-          ssr: {
-            resolve: {
-              external: [...externals]
-            }
-          }
-        }
-      };
-    }
-  };
-}
-
-// src/scaffold/index.ts
-import fs5 from "node:fs/promises";
-import path6 from "node:path";
-
-// src/scaffold/localized-content.ts
-var SCAFFOLD_LANGUAGES = [
-  "en",
-  "ja",
-  "zh-CN",
-  "es",
-  "de",
-  "fr",
-  "ko"
-];
-function defaultLanguageForLocale(locale) {
-  const normalized = locale.toLowerCase();
-  if (normalized.startsWith("ja")) return "ja";
-  if (normalized.startsWith("zh")) return "zh-CN";
-  if (normalized.startsWith("es")) return "es";
-  if (normalized.startsWith("de")) return "de";
-  if (normalized.startsWith("fr")) return "fr";
-  if (normalized.startsWith("ko")) return "ko";
-  return "en";
-}
-var HELPERS = {
-  en: "https://github.com/Rerurate514/riebeckite/blob/main/docs/en/README.md",
-  ja: "https://github.com/Rerurate514/riebeckite/blob/main/docs/ja/README.md"
-};
-var PLUGIN_INDEX_URL = "https://github.com/Rerurate514/riebeckite/tree/main/packages/plugins";
-var THEMES_INDEX_URL = "https://github.com/Rerurate514/riebeckite/tree/main/packages/themes";
-function pluginReadmeUrl(slug) {
-  return `https://github.com/Rerurate514/riebeckite/blob/main/packages/plugins/${slug}/README.md`;
-}
-function themeReadmeUrl(slug) {
-  return `https://github.com/Rerurate514/riebeckite/blob/main/packages/themes/${slug}/README.md`;
-}
-function localizedContentFiles(variables) {
-  const defaultLang = defaultLanguageForLocale(variables.locale);
-  const pages = [
-    { basePath: "index", build: (language) => indexContent(variables, language) },
-    { basePath: "framework/plugins", build: (language) => pluginsContent(language) },
-    { basePath: "framework/themes", build: (language) => themesContent(language) }
-  ];
-  const files = [];
-  for (const page of pages) {
-    for (const language of SCAFFOLD_LANGUAGES) {
-      const suffix = language === defaultLang ? "" : `.${language}`;
-      files.push({
-        path: `content/${page.basePath}${suffix}.md`,
-        content: page.build(language)
-      });
-    }
-  }
-  return files;
-}
-function read(text, language) {
-  return text[language];
-}
-function frontmatter() {
-  return ["---", "publish: true", "---", ""].join("\n");
+function frontmatter() {
+  return ["---", "publish: true", "---", ""].join("\n");
 }
 function heading(level, text) {
   return `${"#".repeat(level)} ${text}`;
@@ -1539,18 +1221,18 @@ function packageJson(variables) {
         inspect: "riebeckite inspect"
       },
       dependencies: {
-        "@riebeckite/core": "^0.0.1",
-        "@riebeckite/honox": "^0.0.1",
-        "@riebeckite/plugin-color-mode": "^0.0.1",
-        "@riebeckite/plugin-l10n": "^0.0.1",
-        "@riebeckite/plugin-obsidian-markdown": "^0.0.1",
-        "@riebeckite/theme-default": "^0.0.1",
+        "@riebeckite/core": "^0.0.3",
+        "@riebeckite/honox": "^0.0.3",
+        "@riebeckite/plugin-color-mode": "^0.0.3",
+        "@riebeckite/plugin-l10n": "^0.0.3",
+        "@riebeckite/plugin-obsidian-markdown": "^0.0.3",
+        "@riebeckite/theme-default": "^0.0.3",
         hono: "^4.12.25",
         honox: "0.1.56"
       },
       devDependencies: {
         "@hono/vite-build": "^1.11.1",
-        "@riebeckite/cli": "^0.0.1",
+        "@riebeckite/cli": "^0.0.3",
         "@types/node": "^24.5.2",
         typescript: "^5.0.0",
         vite: "^8.0.9"
@@ -2102,7 +1784,7 @@ var ScaffoldSiteError = class extends Error {
   }
 };
 async function scaffoldRiebeckiteSite(options) {
-  const targetDirectory = path6.resolve(options.targetDirectory);
+  const targetDirectory = path4.resolve(options.targetDirectory);
   const files = siteTemplateFiles(templateVariables(options, targetDirectory));
   await assertTargetWritable(
     targetDirectory,
@@ -2110,15 +1792,15 @@ async function scaffoldRiebeckiteSite(options) {
     options.overwrite ?? false
   );
   for (const file of files) {
-    const filePath = path6.join(targetDirectory, file.path);
-    await fs5.mkdir(path6.dirname(filePath), { recursive: true });
-    await fs5.writeFile(filePath, file.content, "utf8");
+    const filePath = path4.join(targetDirectory, file.path);
+    await fs4.mkdir(path4.dirname(filePath), { recursive: true });
+    await fs4.writeFile(filePath, file.content, "utf8");
   }
   return { targetDirectory, files: files.map((file) => file.path) };
 }
 function templateVariables(options, targetDirectory) {
   const name = normalizePackageName(
-    options.name ?? path6.basename(targetDirectory)
+    options.name ?? path4.basename(targetDirectory)
   );
   return {
     name,
@@ -2131,7 +1813,7 @@ function templateVariables(options, targetDirectory) {
 async function assertTargetWritable(targetDirectory, files, overwrite) {
   let entries;
   try {
-    entries = await fs5.readdir(targetDirectory);
+    entries = await fs4.readdir(targetDirectory);
   } catch (error) {
     if (isNotFoundError(error)) return;
     throw error;
@@ -2154,6 +1836,427 @@ function normalizePackageName(value) {
 function isNotFoundError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+
+// src/ssg_plugin.ts
+import { defaultExtensionMap, toSSG } from "hono/ssg";
+import { relative } from "node:path";
+import { createServer } from "vite";
+var defaultEntry = "./src/index.tsx";
+function riebeckiteSsg(options = {}) {
+  const virtualId = "virtual:riebeckite-ssg-void-entry";
+  const resolvedVirtualId = `\0${virtualId}`;
+  const entry = options.entry ?? defaultEntry;
+  let resolvedConfig;
+  return {
+    name: "riebeckite-ssg",
+    apply: "build",
+    enforce: "post",
+    config() {
+      return {
+        build: {
+          rollupOptions: {
+            input: [virtualId]
+          }
+        }
+      };
+    },
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    resolveId(id) {
+      return id === virtualId ? resolvedVirtualId : void 0;
+    },
+    load(id) {
+      return id === resolvedVirtualId ? 'console.log("suppress empty chunk message")' : void 0;
+    },
+    async generateBundle(_outputOptions, bundle) {
+      const config = resolvedConfig;
+      if (!config) {
+        throw new Error("Riebeckite SSG could not resolve the Vite configuration.");
+      }
+      removeVirtualEntryChunk(bundle, resolvedVirtualId);
+      const server2 = await createServer({
+        root: config.root,
+        define: config.define,
+        resolve: {
+          ...config.resolve,
+          builtins: [...config.resolve.builtins, /^node:/]
+        },
+        plugins: [],
+        build: { ssr: true },
+        mode: config.mode
+      });
+      try {
+        const module = await server2.ssrLoadModule(entry);
+        const app = module.default;
+        if (!app) {
+          throw new Error(`Failed to find a default export from ${entry}.`);
+        }
+        const generatedHtml = [];
+        const result = await toSSG(
+          app,
+          {
+            writeFile: async (filePath, data) => {
+              const fileName = relative(config.build.outDir, filePath).replaceAll(
+                "\\",
+                "/"
+              );
+              if (fileName.endsWith(".html") && typeof data === "string") {
+                generatedHtml.push({ path: fileName, html: data });
+              }
+              this.emitFile({
+                type: "asset",
+                fileName,
+                source: data
+              });
+            },
+            async mkdir() {
+            }
+          },
+          {
+            dir: config.build.outDir,
+            plugins: options.plugins ?? [],
+            extensionMap: options.extensionMap ?? defaultExtensionMap
+          }
+        );
+        if (!result.success) throw result.error;
+        await emitGeneratedOutputs(
+          module,
+          (asset) => this.emitFile(asset)
+        );
+        inspectGeneratedHtmlPages(module, generatedHtml, {
+          warn: (message) => this.warn(message),
+          info: (message) => this.info(message)
+        });
+      } finally {
+        await server2.close();
+      }
+    }
+  };
+}
+async function emitGeneratedOutputs(module, emit) {
+  const content = module.content;
+  if (!content) return;
+  const manifest = await content.getManifest();
+  for (const output of manifest.generatedOutputs ?? []) {
+    emit({
+      type: "asset",
+      fileName: output.path,
+      source: output.content
+    });
+  }
+}
+function inspectGeneratedHtmlPages(module, pages, log) {
+  const plugins = module.config?.plugins ?? [];
+  for (const plugin of plugins) {
+    const inspector = plugin.inspectGeneratedHtml;
+    if (typeof inspector !== "function") continue;
+    for (const page of pages) {
+      for (const diagnostic of inspector(page) ?? []) {
+        const label = `[${plugin.name ?? "plugin"}] ${page.path}: ${diagnostic.message}`;
+        if (diagnostic.severity === "info") log.info(label);
+        else log.warn(label);
+      }
+    }
+  }
+}
+function removeVirtualEntryChunk(bundle, virtualEntryId) {
+  for (const chunk of Object.values(bundle)) {
+    if (chunk.type === "chunk" && chunk.moduleIds?.includes(virtualEntryId)) {
+      delete bundle[chunk.fileName];
+    }
+  }
+}
+
+// src/ssg.ts
+var defaultSsgEntry = "./app/server.ts";
+function riebeckiteSsgExtensionMap() {
+  return {
+    "application/atom+xml": "xml",
+    "application/json": "json",
+    "application/rss+xml": "xml",
+    "application/xml": "xml",
+    "text/html": "html",
+    "text/plain": "txt",
+    "text/xml": "xml"
+  };
+}
+function createRiebeckiteSsg(options = {}) {
+  return riebeckiteSsg({
+    ...options,
+    entry: options.entry ?? defaultSsgEntry,
+    extensionMap: {
+      ...riebeckiteSsgExtensionMap(),
+      ...options.extensionMap
+    }
+  });
+}
+
+// src/vite_plugin.ts
+import path7 from "node:path";
+
+// src/asset_entries.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { uniqueStrings } from "@riebeckite/core";
+function writeRiebeckiteAssetEntries(config, paths2) {
+  writeGeneratedFile(paths2.pluginStyles, createPluginStylesEntry(config));
+  writeGeneratedFile(paths2.themeStyles, createThemeStylesEntry(config));
+}
+function createPluginStylesEntry(config) {
+  return createStylesheetEntry(
+    collectPluginStyleSpecifiers(config),
+    "Plugin default styles, in resolved plugin order. Generated by @riebeckite/honox; do not edit. Import this before the theme stylesheet so a theme can override plugin defaults."
+  );
+}
+function createThemeStylesEntry(config) {
+  return createStylesheetEntry(
+    config.theme.styles.map((style2) => style2.moduleSpecifier),
+    "Theme styles. Generated by @riebeckite/honox; do not edit. Import this after the plugin stylesheet so the theme wins the plugin/theme cascade."
+  );
+}
+function collectPluginStyleSpecifiers(config) {
+  return config.plugins.flatMap(
+    (plugin) => (plugin.assets ?? []).filter((asset) => asset.kind === "style").map((asset) => asset.moduleSpecifier)
+  );
+}
+function createStylesheetEntry(moduleSpecifiers, banner) {
+  const imports = uniqueStrings(moduleSpecifiers).map((specifier) => `@import ${JSON.stringify(specifier)};`).join("\n");
+  if (!banner) return imports;
+  const header = `/* ${banner.replace(/\*\//g, "* /")} */`;
+  return imports ? `${header}
+${imports}
+` : `${header}
+`;
+}
+function writeGeneratedFile(filePath, contents) {
+  fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+  fs5.writeFileSync(filePath, contents);
+}
+
+// src/client_module.ts
+import {
+  serializePublicClientConfig
+} from "@riebeckite/core";
+var clientModuleId = "virtual:riebeckite/client";
+var resolvedClientModuleId = `\0${clientModuleId}`;
+function riebeckiteClientModule(getConfig) {
+  return {
+    name: "riebeckite-client-module",
+    resolveId(id) {
+      if (id === clientModuleId) return resolvedClientModuleId;
+      return null;
+    },
+    load(id) {
+      if (id !== resolvedClientModuleId) return null;
+      return createClientModule(getConfig());
+    }
+  };
+}
+function createClientModule(config) {
+  const imports = [];
+  const initializers = [];
+  for (const [index, entry] of config.plugins.flatMap((plugin) => plugin.clientEntries ?? []).entries()) {
+    const localName = `pluginClientInitializer${index}`;
+    const importTarget = entry.exportName ? `{ ${entry.exportName} as ${localName} }` : localName;
+    imports.push(
+      `import ${importTarget} from ${JSON.stringify(entry.moduleSpecifier)};`
+    );
+    const publicConfig = entry.publicConfig;
+    initializers.push(
+      publicConfig === void 0 ? `${localName}()` : `${localName}(${serializePublicClientConfig(publicConfig)})`
+    );
+  }
+  return `${imports.join("\n")}
+
+export function initRiebeckiteClient() {
+${initializers.map((initializer) => `  ${initializer};`).join("\n")}
+}
+`;
+}
+
+// src/vite_runner.ts
+import fs6 from "node:fs/promises";
+import path6 from "node:path";
+import { build, createServer as createServer2 } from "vite";
+var viteConfigFileNames = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+async function resolveHonoxApplicationRoot(configRoot) {
+  const roots = await findViteApplicationRoots(configRoot);
+  if (roots.length === 1) return roots[0];
+  if (roots.length === 0) {
+    throw new HonoxApplicationRootError(
+      `Could not find a Vite application under ${configRoot}.`
+    );
+  }
+  throw new HonoxApplicationRootError(
+    `Found multiple Vite applications under ${configRoot}: ${roots.join(", ")}.`
+  );
+}
+var HonoxApplicationRootError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HonoxApplicationRootError";
+  }
+};
+async function resolveHonoxApplication(options) {
+  const configRoot = path6.resolve(options.configRoot);
+  const appRoot = options.appRoot ? path6.resolve(options.appRoot) : await resolveHonoxApplicationRoot(configRoot);
+  const workspaceRoot = options.workspaceRoot ?? await findWorkspaceRoot(configRoot);
+  const rawConfig = await loadRiebeckiteConfig({
+    configRoot,
+    configFile: options.configFile,
+    workspaceRoot
+  });
+  const config = resolveHonoxConfig(rawConfig, appRoot);
+  return {
+    config,
+    configRoot,
+    appRoot,
+    contentRoot: config.content.directory
+  };
+}
+async function findWorkspaceRoot(configRoot) {
+  try {
+    const workspaceConfig = path6.join(configRoot, "pnpm-workspace.yaml");
+    return (await fs6.stat(workspaceConfig)).isFile() ? configRoot : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function startHonoxDevServer(options) {
+  const server2 = await createServer2({ root: options.root });
+  await server2.listen();
+  server2.printUrls();
+  await waitForShutdown(server2);
+}
+async function buildHonoxApplication(options) {
+  await runTraced(
+    options.tracer,
+    "integration.honox.client_build",
+    () => build({ root: options.root, mode: "client" })
+  );
+  await runTraced(
+    options.tracer,
+    "integration.honox.server_build",
+    () => build({ root: options.root })
+  );
+}
+async function runTraced(tracer, name, buildTask) {
+  return tracer ? await tracer.span(name, {}, buildTask) : await buildTask();
+}
+async function waitForShutdown(server2) {
+  await new Promise((resolve) => {
+    const close = () => {
+      void server2.close().finally(resolve);
+    };
+    process.once("SIGINT", close);
+    process.once("SIGTERM", close);
+  });
+}
+async function findViteApplicationRoots(root) {
+  const directories = [root];
+  const applicationRoots = [];
+  while (directories.length > 0) {
+    const directory = directories.pop();
+    if (!directory) continue;
+    if (await hasViteConfig(directory)) applicationRoots.push(directory);
+    const entries = await fs6.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git" || entry.name === "tests") {
+        continue;
+      }
+      directories.push(path6.join(directory, entry.name));
+    }
+  }
+  return applicationRoots;
+}
+async function hasViteConfig(directory) {
+  for (const fileName of viteConfigFileNames) {
+    try {
+      if ((await fs6.stat(path6.join(directory, fileName))).isFile()) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
+// src/vite_plugin.ts
+var defaultSsrExternals = [
+  "extend",
+  "debug",
+  "node:fs/promises",
+  "node:path",
+  "parse-numeric-range",
+  "slugify",
+  "vfile-matter",
+  "yaml"
+];
+function riebeckite(options = {}) {
+  let resolvedConfig;
+  const getConfig = () => {
+    if (!resolvedConfig) {
+      throw new Error("Riebeckite config has not been loaded yet.");
+    }
+    return resolvedConfig;
+  };
+  return [
+    {
+      name: "riebeckite-host-integration",
+      async config(userConfig) {
+        const root = userConfig.root ? path7.resolve(userConfig.root) : process.cwd();
+        const appRoot = options.appRoot ?? root;
+        const application = await resolveHonoxApplication({
+          configRoot: options.configRoot ?? appRoot,
+          configFile: options.configFile,
+          appRoot,
+          workspaceRoot: options.workspaceRoot
+        });
+        resolvedConfig = application.config;
+        writeRiebeckiteAssetEntries(resolvedConfig, {
+          pluginStyles: path7.join(appRoot, "app/.riebeckite/plugin-styles.css"),
+          themeStyles: path7.join(appRoot, "app/.riebeckite/theme-styles.css")
+        });
+        return {
+          define: {
+            "process.env.RIEBECKITE_APP_ROOT": JSON.stringify(appRoot)
+          },
+          resolve: {
+            alias: options.workspaceRoot ? createWorkspacePackageAliases(options.workspaceRoot) : []
+          }
+        };
+      }
+    },
+    riebeckiteClientModule(getConfig)
+  ];
+}
+function riebeckiteVite(options = {}) {
+  const { ssg, ssrExternals, ...integration } = options;
+  return [
+    ...riebeckite(integration),
+    riebeckiteSsrExternals([...defaultSsrExternals, ...ssrExternals ?? []]),
+    createRiebeckiteSsg(ssg)
+  ];
+}
+function riebeckiteSsrExternals(externals) {
+  return {
+    name: "riebeckite-ssr-externals",
+    config() {
+      return {
+        environments: {
+          ssr: {
+            resolve: {
+              external: [...externals]
+            }
+          }
+        }
+      };
+    }
+  };
+}
 export {
   ScaffoldSiteError,
   buildHonoxApplication,
@@ -2161,6 +2264,7 @@ export {
   defaultSsgEntry,
   defaultSsrExternals,
   loadRiebeckiteConfig,
+  replaceHonoxIslandDependencyPlugin,
   resolveHonoxApplication,
   resolveHonoxApplicationRoot,
   resolveHonoxConfig,

package/dist/src/client_module.d.ts

@@ -1,3 +1,3 @@
-import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import { type ResolvedRiebeckiteConfig } from "@riebeckite/core";
 import type { Plugin } from "vite";
 export declare function riebeckiteClientModule(getConfig: () => ResolvedRiebeckiteConfig): Plugin;

package/dist/src/honox_islands.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from "vite";
+type HonoxPlugin = Plugin | Promise<Plugin>;
+/**
+ * Replaces HonoX's dependency walker with one that remains inside the app
+ * directory. Riebeckite configurations import plugins with large dependency
+ * graphs, which must not be traversed merely to determine whether a route
+ * imports an island.
+ */
+export declare function replaceHonoxIslandDependencyPlugin(plugins: HonoxPlugin[]): HonoxPlugin[];
+export {};

package/dist/src/vite_plugin.d.ts

@@ -11,7 +11,7 @@ export type RiebeckiteIntegrationOptions = {
  * external. These are internal to the integration: sites should not have to
  * restate the Vite `environments.ssr.resolve.external` list.
  */
-export declare const defaultSsrExternals: readonly ["extend", "debug", "node:fs/promises", "node:path", "parse-numeric-range", "slugify", "vfile-matter"];
+export declare const defaultSsrExternals: readonly ["extend", "debug", "node:fs/promises", "node:path", "parse-numeric-range", "slugify", "vfile-matter", "yaml"];
 export type RiebeckiteViteOptions = RiebeckiteIntegrationOptions & {
     /** Extra SSR externals appended after Riebeckite's defaults. */
     ssrExternals?: readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/honox",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,10 +26,11 @@
     }
   },
   "dependencies": {
+    "@babel/parser": "^7.29.3",
     "esbuild": "^0.28.2",
     "hono": "^4.12.25",
     "vite": "^8.0.9",
-    "@riebeckite/core": "0.0.1"
+    "@riebeckite/core": "0.0.3"
   },
   "publishConfig": {
     "access": "public"