@riebeckite/honox 0.0.1

package/dist/index.js

@@ -0,0 +1,1091 @@
+// src/config_loader.ts
+import fs2 from "node:fs/promises";
+import os from "node:os";
+import path2 from "node:path";
+import { build as buildWithEsbuild } from "esbuild";
+
+// src/workspace_packages.ts
+import fs from "node:fs";
+import path from "node:path";
+function createWorkspacePackageAliases(workspaceRoot) {
+  const packagesRoot = path.join(workspaceRoot, "packages");
+  if (!fs.existsSync(packagesRoot)) return [];
+  return findWorkspacePackageDirectories(packagesRoot).flatMap(
+    (packageDirectory) => {
+      const packageJsonPath = path.join(packageDirectory, "package.json");
+      const packageJson2 = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      if (typeof packageJson2.name !== "string") return [];
+      return createPackageAliases(
+        packageJson2.name,
+        packageDirectory,
+        packageJson2
+      );
+    }
+  );
+}
+function workspacePackageResolver(workspaceRoot) {
+  const aliases = createWorkspacePackageAliases(workspaceRoot);
+  return {
+    name: "workspace-package-resolver",
+    setup(buildApi) {
+      buildApi.onResolve({ filter: /.*/ }, (args) => {
+        const alias = aliases.find(
+          (currentAlias) => currentAlias.find.test(args.path)
+        );
+        return alias ? { path: alias.replacement } : null;
+      });
+    }
+  };
+}
+function findWorkspacePackageDirectories(rootDirectory) {
+  const packageJsonPath = path.join(rootDirectory, "package.json");
+  if (fs.existsSync(packageJsonPath)) return [rootDirectory];
+  return fs.readdirSync(rootDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap(
+    (entry) => findWorkspacePackageDirectories(path.join(rootDirectory, entry.name))
+  );
+}
+function createPackageAliases(packageName, packageDirectory, packageJson2) {
+  const aliases = [];
+  const mainEntry = resolveExportsEntry(packageJson2.exports) ?? packageJson2.main;
+  if (mainEntry) {
+    aliases.push({
+      find: new RegExp(`^${escapeRegExp(packageName)}$`),
+      replacement: path.join(packageDirectory, mainEntry)
+    });
+  }
+  if (!packageJson2.exports || typeof packageJson2.exports !== "object") {
+    return aliases;
+  }
+  for (const [subpath, target] of Object.entries(packageJson2.exports)) {
+    if (subpath === "." || !subpath.startsWith(".")) continue;
+    const resolvedTarget = resolveExportTarget(target);
+    if (!resolvedTarget) continue;
+    aliases.push({
+      find: new RegExp(`^${escapeRegExp(packageName + subpath.slice(1))}$`),
+      replacement: path.join(packageDirectory, resolvedTarget)
+    });
+  }
+  return aliases;
+}
+function resolveExportsEntry(exportsField) {
+  if (typeof exportsField === "string") return exportsField;
+  if (!exportsField || typeof exportsField !== "object") return void 0;
+  const rootTarget = exportsField["."];
+  if (rootTarget !== void 0) return resolveExportTarget(rootTarget);
+  const hasSubpaths = Object.keys(exportsField).some(
+    (key) => key.startsWith(".")
+  );
+  if (hasSubpaths) return void 0;
+  return resolveExportTarget(exportsField);
+}
+var exportConditionOrder = [
+  "source",
+  "import",
+  "module",
+  "browser",
+  "default",
+  "node",
+  "require",
+  "types"
+];
+function resolveExportTarget(target) {
+  if (typeof target === "string") return target;
+  if (!target || typeof target !== "object") return void 0;
+  const record = target;
+  for (const condition of exportConditionOrder) {
+    if (condition in record) {
+      const resolved = resolveExportTarget(record[condition]);
+      if (resolved) return resolved;
+    }
+  }
+  for (const value of Object.values(record)) {
+    const resolved = resolveExportTarget(value);
+    if (resolved) return resolved;
+  }
+  return void 0;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/config_loader.ts
+async function loadRiebeckiteConfig(options) {
+  const configFile = options.configFile ?? "riebeckite.config.ts";
+  const temporaryDirectory = await fs2.mkdtemp(
+    path2.join(os.tmpdir(), "riebeckite-config-")
+  );
+  const outputFile = path2.join(temporaryDirectory, "config.mjs");
+  try {
+    await buildWithEsbuild({
+      stdin: {
+        contents: `
+          import rawConfig from ${JSON.stringify(path2.resolve(options.configRoot, configFile))};
+          import { resolveConfigModule } from "@riebeckite/core";
+          export default resolveConfigModule(rawConfig);
+        `,
+        resolveDir: options.configRoot,
+        loader: "ts"
+      },
+      outfile: outputFile,
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      banner: {
+        js: 'import { createRequire as __riebeckiteCreateRequire } from "node:module"; const require = __riebeckiteCreateRequire(import.meta.url);'
+      },
+      plugins: options.workspaceRoot ? [workspacePackageResolver(options.workspaceRoot)] : []
+    });
+    const module = await import(`${pathToFileUrl(outputFile)}?t=${Date.now()}`);
+    return module.default;
+  } finally {
+    await fs2.rm(temporaryDirectory, { recursive: true, force: true });
+  }
+}
+function resolveHonoxConfig(config, appRoot) {
+  return {
+    ...config,
+    content: {
+      ...config.content,
+      directory: path2.resolve(appRoot, config.content.directory)
+    }
+  };
+}
+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;
+  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 path5 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));
+}
+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) {
+  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/templates.ts
+function siteTemplateFiles(variables) {
+  return [
+    { path: "package.json", content: packageJson(variables) },
+    { path: "riebeckite.config.ts", content: riebeckiteConfig(variables) },
+    { path: "vite.config.ts", content: viteConfig() },
+    { path: "tsconfig.json", content: tsconfig() },
+    { path: ".gitignore", content: gitignore() },
+    { path: "README.md", content: readme(variables) },
+    { path: "content/index.md", content: indexContent(variables) },
+    { path: "app/server.ts", content: server() },
+    { path: "app/client.ts", content: client() },
+    { path: "app/config.ts", content: appConfig() },
+    { path: "app/content.ts", content: appContent() },
+    { path: "app/constants/paths.ts", content: paths() },
+    { path: "app/global.d.ts", content: globalDeclarations() },
+    { path: "app/style.css", content: style() },
+    { path: "app/components/site-header.tsx", content: siteHeader() },
+    { path: "app/components/article.tsx", content: article() },
+    { path: "app/routes/_renderer.tsx", content: renderer() },
+    { path: "app/routes/index.tsx", content: indexRoute() },
+    { path: "app/routes/[slug{.+}].tsx", content: slugRoute() }
+  ];
+}
+function packageJson(variables) {
+  return `${JSON.stringify(
+    {
+      name: variables.name,
+      private: true,
+      version: "0.0.0",
+      type: "module",
+      scripts: {
+        dev: "riebeckite dev",
+        build: "riebeckite build",
+        check: "riebeckite check",
+        doctor: "riebeckite doctor",
+        inspect: "riebeckite inspect"
+      },
+      dependencies: {
+        "@riebeckite/core": "^0.0.1",
+        "@riebeckite/honox": "^0.0.1",
+        "@riebeckite/plugin-obsidian-markdown": "^0.0.1",
+        "@riebeckite/theme-default": "^0.0.1",
+        hono: "^4.12.25",
+        honox: "0.1.56"
+      },
+      devDependencies: {
+        "@hono/vite-build": "^1.11.1",
+        "@riebeckite/cli": "^0.0.1",
+        "@types/node": "^24.5.2",
+        typescript: "^5.0.0",
+        vite: "^8.0.9"
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+function riebeckiteConfig(variables) {
+  return `import { defineConfig } from "@riebeckite/core";
+import { obsidianMarkdown } from "@riebeckite/plugin-obsidian-markdown";
+import { defaultTheme } from "@riebeckite/theme-default";
+
+export default defineConfig({
+  site: {
+    title: ${JSON.stringify(variables.title)},
+    description: ${JSON.stringify(variables.description)},
+    baseUrl: ${JSON.stringify(variables.baseUrl)},
+    locale: ${JSON.stringify(variables.locale)},
+  },
+  content: {
+    directory: "content",
+  },
+  theme: defaultTheme(),
+  plugins: [obsidianMarkdown()],
+});
+`;
+}
+function viteConfig() {
+  return `import path from "node:path";
+import { fileURLToPath } from "node:url";
+import build from "@hono/vite-build/node";
+import {
+  riebeckite,
+  riebeckiteSsg,
+  riebeckiteSsgExtensionMap,
+} from "@riebeckite/honox";
+import honox from "honox/vite";
+import { defineConfig } from "vite";
+
+const appRoot = fileURLToPath(new URL(".", import.meta.url));
+
+export default defineConfig({
+  plugins: [
+    honox({
+      client: { input: ["/app/client.ts", "/app/style.css"] },
+    }),
+    riebeckite({ appRoot }),
+    build(),
+    riebeckiteSsg({
+      entry: path.join(appRoot, "app/server.ts"),
+      extensionMap: riebeckiteSsgExtensionMap(),
+    }),
+  ],
+  environments: {
+    ssr: {
+      resolve: {
+        external: [
+          "extend",
+          "debug",
+          "node:fs/promises",
+          "node:path",
+          "parse-numeric-range",
+          "slugify",
+          "vfile-matter",
+        ],
+      },
+    },
+  },
+});
+`;
+}
+function tsconfig() {
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        jsx: "react-jsx",
+        jsxImportSource: "hono/jsx",
+        types: ["node", "vite/client"],
+        strict: true,
+        noEmit: true,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        resolveJsonModule: true,
+        skipLibCheck: true
+      },
+      include: [
+        "app/**/*.ts",
+        "app/**/*.tsx",
+        "riebeckite.config.ts",
+        "vite.config.ts"
+      ]
+    },
+    null,
+    2
+  )}
+`;
+}
+function gitignore() {
+  return ["node_modules/", "dist/", ".riebeckite/", ""].join("\n");
+}
+function readme(variables) {
+  return [
+    `# ${variables.title}`,
+    "",
+    "A minimal Riebeckite site generated by `riebeckite init`.",
+    "",
+    "## Commands",
+    "",
+    "```sh",
+    "pnpm install",
+    "pnpm exec riebeckite check",
+    "pnpm exec riebeckite dev",
+    "pnpm exec riebeckite build",
+    "```",
+    "",
+    "Content lives in `content/`. The site owns `app/routes`, `app/components`,",
+    "`app/islands`, and `app/style.css`; see the Riebeckite HonoX integration",
+    "documentation for the site application contract.",
+    ""
+  ].join("\n");
+}
+function indexContent(variables) {
+  return [
+    "---",
+    "publish: true",
+    "---",
+    "",
+    `# ${variables.title}`,
+    "",
+    "Welcome to your Riebeckite site.",
+    "",
+    "Edit `content/index.md` to change this page, and add more Markdown files",
+    "next to it. Files need `publish: true` frontmatter before they appear.",
+    ""
+  ].join("\n");
+}
+function server() {
+  return `import { mountRiebeckiteEndpoints } from "@riebeckite/honox/server";
+import { createApp } from "honox/server";
+import { config } from "./config";
+import { content } from "./content";
+
+const app = createApp({
+  init: (app) => {
+    mountRiebeckiteEndpoints(app, { config, content });
+  },
+});
+
+export default app;
+`;
+}
+function client() {
+  return `import { initRiebeckiteClient } from "virtual:riebeckite/client";
+import { createClient } from "honox/client";
+
+createClient();
+
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", initPage, { once: true });
+} else {
+  initPage();
+}
+
+function initPage() {
+  initRiebeckiteClient();
+}
+`;
+}
+function appConfig() {
+  return `import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveConfigModule } from "@riebeckite/core";
+import * as rawConfigModule from "../riebeckite.config";
+
+const appRoot =
+  process.env.RIEBECKITE_APP_ROOT ??
+  fileURLToPath(new URL("../", import.meta.url));
+const resolvedConfig = resolveConfigModule(rawConfigModule);
+
+export const config = {
+  ...resolvedConfig,
+  content: {
+    ...resolvedConfig.content,
+    directory: path.resolve(appRoot, resolvedConfig.content.directory),
+  },
+};
+`;
+}
+function appContent() {
+  return `import { ContentManager } from "@riebeckite/core";
+import { config } from "./config";
+import { CONTENT_DIR } from "./constants/paths";
+
+export const content = new ContentManager(
+  CONTENT_DIR,
+  config.content.exclude,
+  {
+    config,
+    plugins: config.plugins,
+  },
+);
+`;
+}
+function paths() {
+  return `import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { config } from "../config";
+
+const appRoot =
+  process.env.RIEBECKITE_APP_ROOT ??
+  fileURLToPath(new URL("../../", import.meta.url));
+
+export const CONTENT_DIR = path.resolve(appRoot, config.content.directory);
+export const ASSETS_ROOT = "public/";
+`;
+}
+function globalDeclarations() {
+  return `declare module "virtual:riebeckite/client" {
+  export function initRiebeckiteClient(): void;
+}
+`;
+}
+function style() {
+  return `@import "./.riebeckite/plugin-styles.css";
+@import "./.riebeckite/theme-styles.css";
+
+body {
+  margin: 0;
+  font-family: system-ui, sans-serif;
+}
+
+.site-header {
+  display: flex;
+  gap: 1rem;
+  padding: 1rem;
+  border-bottom: 1px solid #d1d5db;
+}
+
+.site-header__home {
+  color: #111827;
+  font-weight: 700;
+  text-decoration: none;
+}
+
+.site-article {
+  display: block;
+  max-width: 48rem;
+  padding: 2rem 1rem;
+  margin: 0 auto;
+}
+`;
+}
+function siteHeader() {
+  return `import { config } from "../config";
+
+export function SiteHeader() {
+  return (
+    <header class="site-header">
+      <a href="/" class="site-header__home">
+        {config.site.title}
+      </a>
+    </header>
+  );
+}
+`;
+}
+function article() {
+  return `import type { PostContent } from "@riebeckite/core";
+import { Article, ArticleContent, ArticleLayout } from "@riebeckite/honox/ui";
+
+export function SiteArticle({ post }: { post: PostContent }) {
+  return (
+    <Article class="site-article">
+      <ArticleLayout>
+        <ArticleContent>
+          <div dangerouslySetInnerHTML={{ __html: post.html ?? "" }} />
+        </ArticleContent>
+      </ArticleLayout>
+    </Article>
+  );
+}
+`;
+}
+function renderer() {
+  return `import { jsxRenderer } from "hono/jsx-renderer";
+import { Link, Script } from "honox/server";
+import { SiteHeader } from "../components/site-header";
+import { config } from "../config";
+
+function themeAttributes() {
+  const { theme } = config;
+
+  return {
+    ...theme.attributes,
+    "data-theme": theme.colorMode === "system" ? undefined : theme.colorMode,
+    "data-theme-name": theme.name,
+    "data-typography": theme.typography,
+    "data-article-layout": theme.articleLayout,
+  };
+}
+
+export default jsxRenderer(({ children }) => {
+  return (
+    <html lang={config.site.locale} {...themeAttributes()}>
+      <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>{config.site.title}</title>
+        <Link href="/app/style.css" rel="stylesheet" />
+        <Script src="/app/client.ts" async />
+      </head>
+      <body class="riebeckite-page">
+        <SiteHeader />
+        {children}
+      </body>
+    </html>
+  );
+});
+`;
+}
+function indexRoute() {
+  return `import { isPublished } from "@riebeckite/core";
+import { createRoute } from "honox/factory";
+import { SiteArticle } from "../components/article";
+import { config } from "../config";
+import { content } from "../content";
+
+export default createRoute(async (c) => {
+  const manifest = await content.getManifest();
+  const indexEntry = manifest.bySlug.get("index");
+  if (indexEntry && indexEntry.permalink !== "/") {
+    return c.redirect(indexEntry.permalink, 308);
+  }
+
+  const post = await content.getProcessedContent("index");
+  if (!isPublished(config, post.frontmatter)) {
+    return c.notFound();
+  }
+
+  return c.render(<SiteArticle post={post} />);
+});
+`;
+}
+function slugRoute() {
+  return `import { isPublished } from "@riebeckite/core";
+import {
+  contentRouteSsgParams,
+  resolveContentRoute,
+} from "@riebeckite/honox/server";
+import { createRoute } from "honox/factory";
+import { SiteArticle } from "../components/article";
+import { config } from "../config";
+import { content } from "../content";
+
+export default createRoute(
+  contentRouteSsgParams("/:slug{.+}", async () => {
+    const manifest = await content.getManifest();
+    return manifest.entries
+      .filter((entry) => isPublished(config, entry.frontmatter))
+      .filter((entry) => entry.permalink !== "/")
+      .map((entry) => ({ slug: entry.permalink.replace(/^\\/+/, "") }));
+  }),
+  async (c) => {
+    const requestedSlug = c.req.param("slug");
+    if (!requestedSlug) return c.notFound();
+    if (/\\.[a-zA-Z0-9]+$/.test(requestedSlug)) return c.notFound();
+
+    const manifest = await content.getManifest();
+    const route = resolveContentRoute(manifest, c.req.path);
+    if (!route) return c.notFound();
+    if (route.kind === "redirect")
+      return c.redirect(route.location, route.status);
+
+    const post = await content.getProcessedContent(route.entry.slug);
+    if (!isPublished(config, post.frontmatter)) {
+      return c.notFound();
+    }
+
+    return c.render(<SiteArticle post={post} />);
+  },
+);
+`;
+}
+
+// src/scaffold/index.ts
+var ScaffoldSiteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScaffoldSiteError";
+  }
+};
+async function scaffoldRiebeckiteSite(options) {
+  const targetDirectory = path6.resolve(options.targetDirectory);
+  const files = siteTemplateFiles(templateVariables(options, targetDirectory));
+  await assertTargetWritable(
+    targetDirectory,
+    files,
+    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");
+  }
+  return { targetDirectory, files: files.map((file) => file.path) };
+}
+function templateVariables(options, targetDirectory) {
+  const name = normalizePackageName(
+    options.name ?? path6.basename(targetDirectory)
+  );
+  return {
+    name,
+    title: options.siteTitle ?? name,
+    description: options.description ?? "",
+    baseUrl: options.baseUrl ?? "",
+    locale: options.locale ?? "en"
+  };
+}
+async function assertTargetWritable(targetDirectory, files, overwrite) {
+  let entries;
+  try {
+    entries = await fs5.readdir(targetDirectory);
+  } catch (error) {
+    if (isNotFoundError(error)) return;
+    throw error;
+  }
+  const conflicts = entries.filter(
+    (entry) => files.some((file) => file.path.split("/")[0] === entry)
+  );
+  if (conflicts.length === 0) return;
+  if (overwrite) return;
+  throw new ScaffoldSiteError(
+    `The target directory is not empty: ${targetDirectory}
+Existing entries: ${conflicts.slice(0, 5).join(", ")}
+Pass --force to overwrite generated files.`
+  );
+}
+function normalizePackageName(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-_.]+/, "").replace(/[-_.]+$/, "");
+  return normalized || "riebeckite-site";
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+export {
+  ScaffoldSiteError,
+  buildHonoxApplication,
+  createRiebeckiteSsg,
+  defaultSsgEntry,
+  defaultSsrExternals,
+  loadRiebeckiteConfig,
+  resolveHonoxApplication,
+  resolveHonoxApplicationRoot,
+  resolveHonoxConfig,
+  riebeckite,
+  riebeckiteSsg,
+  riebeckiteSsgExtensionMap,
+  riebeckiteVite,
+  scaffoldRiebeckiteSite,
+  startHonoxDevServer
+};