@riebeckite/honox 0.0.13 → 0.0.15

package/dist/index.js

@@ -255,11 +255,41 @@ function isJavaScriptModule(filePath) {
 }
 
 // src/scaffold/index.ts
-import fs7 from "node:fs/promises";
-import path7 from "node:path";
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
+
+// src/scaffold/wrangler-defaults.ts
+var WRANGLER_DEFAULTS = {
+  /** JSON schema for IDE support and validation */
+  $schema: "node_modules/wrangler/config-schema.json",
+  /** Worker name - becomes <name>.<account>.workers.dev */
+  name: "riebeckite-site",
+  /** Compatibility date - update when Workers runtime changes require it */
+  compatibility_date: "2026-06-09",
+  /** Required for Node.js APIs used by Riebeckite */
+  compatibility_flags: ["nodejs_compat"],
+  /** Static assets directory - Riebeckite builds to ./dist */
+  assets: { directory: "./dist" }
+};
+var GITHUB_ACTIONS_SECRETS = {
+  /** Cloudflare API token with Workers Scripts: Edit permission */
+  CLOUDFLARE_API_TOKEN: "CLOUDFLARE_API_TOKEN",
+  /** Cloudflare Account ID (found in Workers & Pages dashboard URL) */
+  CLOUDFLARE_ACCOUNT_ID: "CLOUDFLARE_ACCOUNT_ID",
+  /** Optional: Token for content repo to dispatch to site repo */
+  SITE_DISPATCH_TOKEN: "SITE_DISPATCH_TOKEN",
+  /** Optional: Token for site repo to read content repo */
+  RIEBECKITE_CONTENT_READ_TOKEN: "RIEBECKITE_CONTENT_READ_TOKEN"
+};
 
 // src/scaffold/deployment.ts
 var GITHUB_REPOSITORY_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+var BUILD_STATE_CACHE_KEY_PREFIX = "riebeckite-build-v1";
+var LEGACY_BUILD_CACHE_KEY_PREFIX = "riebeckite-content-v3";
+var BUILD_STATE_CACHE_PATHS = [
+  ".riebeckite/cache",
+  ".riebeckite/build/content-state.json"
+];
 function assertGitHubRepository(value, option) {
   if (!GITHUB_REPOSITORY_PATTERN.test(value)) {
     throw new Error(
@@ -295,16 +325,7 @@ function deploymentTemplateFiles(options) {
   ];
 }
 function wranglerConfig() {
-  return `${JSON.stringify(
-    {
-      name: "riebeckite-site",
-      compatibility_date: "2026-03-10",
-      compatibility_flags: ["nodejs_compat"],
-      assets: { directory: "./dist" }
-    },
-    null,
-    2
-  )}
+  return `${JSON.stringify(WRANGLER_DEFAULTS, null, 2)}
 `;
 }
 function deployWorkflow(contentRepository) {
@@ -347,6 +368,16 @@ ${contentCheckout}
       - name: Install dependencies
         run: npm ci
 
+      - name: Restore Riebeckite build state
+        uses: actions/cache@v4
+        with:
+          path: |
+${BUILD_STATE_CACHE_PATHS.map((entry) => `            ${entry}`).join("\n")}
+          key: ${BUILD_STATE_CACHE_KEY_PREFIX}-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}-\${{ github.run_id }}-\${{ github.run_attempt }}
+          restore-keys: |
+            ${BUILD_STATE_CACHE_KEY_PREFIX}-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}-
+            ${LEGACY_BUILD_CACHE_KEY_PREFIX}-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}
+
       - name: Validate configuration and plugins
         run: npm exec riebeckite check
 
@@ -356,8 +387,8 @@ ${contentCheckout}
       - name: Deploy the built assets
         uses: cloudflare/wrangler-action@v3
         with:
-          apiToken: \${{ secrets.CLOUDFLARE_API_TOKEN }}
-          accountId: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          apiToken: \${{ secrets.${GITHUB_ACTIONS_SECRETS.CLOUDFLARE_API_TOKEN} }}
+          accountId: \${{ secrets.${GITHUB_ACTIONS_SECRETS.CLOUDFLARE_ACCOUNT_ID} }}
           command: deploy
 `;
 }
@@ -377,7 +408,7 @@ jobs:
     steps:
       - name: Validate dispatch configuration
         env:
-          SITE_DISPATCH_TOKEN: \${{ secrets.SITE_DISPATCH_TOKEN }}
+          SITE_DISPATCH_TOKEN: \${{ secrets.${GITHUB_ACTIONS_SECRETS.SITE_DISPATCH_TOKEN} }}
         run: |
           if [ -z "$SITE_DISPATCH_TOKEN" ]; then
             echo "::error::SITE_DISPATCH_TOKEN is not configured. Add a token that can dispatch to ${siteRepository}."
@@ -387,7 +418,7 @@ jobs:
       - name: Notify the site repository
         uses: actions/github-script@v7
         with:
-          github-token: \${{ secrets.SITE_DISPATCH_TOKEN }}
+          github-token: \${{ secrets.${GITHUB_ACTIONS_SECRETS.SITE_DISPATCH_TOKEN} }}
           script: |
             await github.rest.repos.createDispatchEvent({
               owner: ${JSON.stringify(owner)},
@@ -924,10 +955,10 @@ function resolveScaffoldPreset(value) {
 }
 
 // src/scaffold/templates.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 
 // src/vite_plugin.ts
-import path6 from "node:path";
+import path8 from "node:path";
 
 // src/asset_entries.ts
 import fs4 from "node:fs";
@@ -1037,11 +1068,288 @@ ${initializers.map((initializer) => `  ${initializer};`).join("\n")}
 `;
 }
 
+// src/content_assets.ts
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
+import {
+  isIgnoredContentPath as isIgnoredContentPath2,
+  isImagePath as isImagePath2,
+  normalizeContentPath as normalizeContentPath2
+} from "@riebeckite/core";
+
+// src/content_watch.ts
+import path5 from "node:path";
+import {
+  isAttachmentPath,
+  isIgnoredContentPath,
+  isImagePath,
+  normalizeContentPath
+} from "@riebeckite/core";
+var CONTENT_RELOAD_DEBOUNCE_MS = 60;
+var configuredWatchers = /* @__PURE__ */ new WeakSet();
+function riebeckiteContentWatch(options) {
+  return {
+    name: "riebeckite-content-watch",
+    apply: "serve",
+    enforce: "post",
+    configureServer(server2) {
+      if (configuredWatchers.has(server2.watcher)) return;
+      configuredWatchers.add(server2.watcher);
+      const appRoot = options.appRoot();
+      const contentRoot = options.contentRoot();
+      const exclude = options.exclude();
+      const isContentFile = (file) => isPathInsideDirectory(contentRoot, file);
+      server2.watcher.add(contentRoot);
+      suppressRestartOnContentEvents(server2, isContentFile);
+      let timer;
+      const invalidate = () => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+          timer = void 0;
+          invalidateApplicationRuntime(server2, appRoot);
+          server2.hot.send({ type: "full-reload" });
+        }, CONTENT_RELOAD_DEBOUNCE_MS);
+      };
+      server2.httpServer?.once("close", () => {
+        if (timer) clearTimeout(timer);
+      });
+      const handle = (event) => (file) => {
+        if (!isContentFile(file)) return;
+        const logicalPath = toLogicalPath(contentRoot, file);
+        if (isIgnoredContentPath(logicalPath, exclude)) return;
+        if (event === "change" && isSiteAssetPath(logicalPath)) {
+          server2.hot.send({ type: "full-reload" });
+          return;
+        }
+        invalidate();
+      };
+      server2.watcher.on("add", handle("add"));
+      server2.watcher.on("change", handle("change"));
+      server2.watcher.on("unlink", handle("unlink"));
+    }
+  };
+}
+function isSiteAssetPath(logicalPath) {
+  return isImagePath(logicalPath) || isAttachmentPath(logicalPath);
+}
+function isPathInsideDirectory(directory, file) {
+  const root = normalizeForCompare(directory).replace(/\/+$/, "");
+  if (!root) return false;
+  const target = normalizeForCompare(file);
+  return target === root || target.startsWith(`${root}/`);
+}
+function toLogicalPath(directory, file) {
+  return normalizeContentPath(
+    path5.relative(normalizeContentPath(directory), normalizeContentPath(file))
+  );
+}
+function invalidateApplicationRuntime(server2, appRoot) {
+  const moduleGraph = server2.environments?.ssr?.moduleGraph;
+  if (!moduleGraph) return 0;
+  const appDirectory = path5.join(appRoot, "app") + path5.sep;
+  const seen = /* @__PURE__ */ new Set();
+  const timestamp = Date.now();
+  let invalidated = 0;
+  for (const mod of moduleGraph.idToModuleMap.values()) {
+    const file = mod.file;
+    if (!file || !isPathInsideDirectory(appDirectory, file)) continue;
+    moduleGraph.invalidateModule(mod, seen, timestamp);
+    invalidated += 1;
+  }
+  return invalidated;
+}
+function suppressRestartOnContentEvents(server2, isContentFile) {
+  for (const event of ["add", "unlink"]) {
+    const listeners = server2.watcher.rawListeners(event).slice();
+    server2.watcher.removeAllListeners(event);
+    for (const listener of listeners) {
+      server2.watcher.on(event, (file) => {
+        if (isContentFile(file)) return;
+        listener(file);
+      });
+    }
+  }
+}
+function normalizeForCompare(value) {
+  const normalized = normalizeContentPath(value);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+// src/content_assets.ts
+var IMAGE_CONTENT_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  webp: "image/webp",
+  bmp: "image/bmp"
+};
+function riebeckiteContentAssets(options) {
+  return {
+    name: "riebeckite-content-assets",
+    apply: "serve",
+    enforce: "pre",
+    configureServer(server2) {
+      const contentRoot = options.contentRoot();
+      const entry = path6.join(options.appRoot(), "app", "server.ts");
+      const base = server2.config.base;
+      const publicDir = server2.config.publicDir;
+      let cachedManifest;
+      let cachedPaths = /* @__PURE__ */ new Set();
+      const resolvePublicImagePaths = async () => {
+        const module = await server2.ssrLoadModule(entry);
+        const manifest = await module.content?.getManifest();
+        if (!manifest) return /* @__PURE__ */ new Set();
+        if (manifest !== cachedManifest) {
+          cachedManifest = manifest;
+          cachedPaths = collectPublicImagePaths(manifest);
+        }
+        return cachedPaths;
+      };
+      const middleware = async (request, response, next) => {
+        try {
+          if (request.method !== "GET" && request.method !== "HEAD") {
+            next();
+            return;
+          }
+          const logicalPath = toContentPath(request.url, base);
+          if (!logicalPath || !isImagePath2(logicalPath)) {
+            next();
+            return;
+          }
+          if (isIgnoredContentPath2(logicalPath)) {
+            next();
+            return;
+          }
+          const contentType = imageContentType(logicalPath);
+          if (!contentType) {
+            next();
+            return;
+          }
+          const available = await resolvePublicImagePaths();
+          if (!available.has(logicalPath)) {
+            next();
+            return;
+          }
+          const file = path6.join(contentRoot, logicalPath);
+          if (!isPathInsideDirectory(contentRoot, file)) {
+            next();
+            return;
+          }
+          if (await hasSiteOwnedFile(publicDir, logicalPath)) {
+            next();
+            return;
+          }
+          const content = await fs5.readFile(file);
+          response.statusCode = 200;
+          response.setHeader("Content-Type", contentType);
+          response.setHeader("Content-Length", String(content.byteLength));
+          response.setHeader("Cache-Control", "no-cache");
+          if (request.method === "HEAD") {
+            response.end();
+            return;
+          }
+          response.end(content);
+          return;
+        } catch {
+          next();
+        }
+      };
+      server2.middlewares.use((request, response, next) => {
+        void middleware(
+          request,
+          response,
+          next
+        );
+      });
+    }
+  };
+}
+function collectPublicImagePaths(manifest) {
+  const paths2 = /* @__PURE__ */ new Set();
+  for (const entry of manifest.publicEntries ?? []) {
+    for (const asset of entry.assets ?? []) {
+      const normalized = normalizeContentPath2(asset.path);
+      if (isImagePath2(normalized)) paths2.add(normalized);
+    }
+  }
+  return paths2;
+}
+async function collectSiteOwnedOutputPaths(publicDir) {
+  const paths2 = /* @__PURE__ */ new Set();
+  if (!publicDir) return paths2;
+  const root = path6.resolve(publicDir);
+  const walk = async (directory) => {
+    const entries = await fs5.readdir(directory, { withFileTypes: true }).catch(() => void 0);
+    if (!entries) return;
+    for (const entry of entries) {
+      const full = path6.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else {
+        paths2.add(path6.relative(root, full).replaceAll("\\", "/"));
+      }
+    }
+  };
+  await walk(root);
+  return paths2;
+}
+function toContentPath(url, base) {
+  if (!url) return void 0;
+  const withoutQuery = url.split("?")[0]?.split("#")[0];
+  if (!withoutQuery) return void 0;
+  let decoded = withoutQuery;
+  try {
+    decoded = decodeURIComponent(withoutQuery);
+  } catch {
+    return void 0;
+  }
+  let pathname = normalizeContentPath2(decoded);
+  if (base && base !== "/" && pathname.startsWith(base)) {
+    pathname = normalizeContentPath2(pathname.slice(base.length));
+  }
+  const logicalPath = pathname.replace(/^\/+/, "");
+  if (!logicalPath) return void 0;
+  if (logicalPath.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    return void 0;
+  }
+  return logicalPath;
+}
+function imageContentType(logicalPath) {
+  const extension = logicalPath.split("/").at(-1)?.split(".").at(-1);
+  if (!extension) return void 0;
+  return IMAGE_CONTENT_TYPES[extension.toLowerCase()];
+}
+async function hasSiteOwnedFile(publicDir, logicalPath) {
+  if (!publicDir) return false;
+  const file = path6.join(publicDir, logicalPath);
+  try {
+    return (await fs5.stat(file)).isFile();
+  } catch {
+    return false;
+  }
+}
+
 // src/ssg_plugin.ts
-import { relative } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename as rename2,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { performance } from "node:perf_hooks";
 import { defaultExtensionMap, toSSG } from "hono/ssg";
-import { createServer } from "vite";
+import {
+  createServer
+} from "vite";
 var defaultEntry = "./src/index.tsx";
+var cloudflareWorkerAssetLimit = 25 * 1024 * 1024;
 function riebeckiteSsg(options = {}) {
   const virtualId = "virtual:riebeckite-ssg-void-entry";
   const resolvedVirtualId = `\0${virtualId}`;
@@ -1049,7 +1357,7 @@ function riebeckiteSsg(options = {}) {
   let resolvedConfig;
   return {
     name: "riebeckite-ssg",
-    apply: "build",
+    apply: shouldApplyRiebeckiteSsg,
     enforce: "post",
     config() {
       return {
@@ -1076,53 +1384,224 @@ function riebeckiteSsg(options = {}) {
           "Riebeckite SSG could not resolve the Vite configuration."
         );
       }
+      const timingsMs = {};
       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
-      });
+      const server2 = await measure(
+        timingsMs,
+        "ssgSetup",
+        () => createServer({
+          root: config.root,
+          define: config.define,
+          resolve: {
+            ...config.resolve,
+            builtins: [...config.resolve.builtins, /^node:/]
+          },
+          plugins: [],
+          build: { ssr: true },
+          mode: config.mode,
+          server: { watch: null }
+        })
+      );
       try {
-        const module = await server2.ssrLoadModule(entry);
+        const module = await measure(
+          timingsMs,
+          "ssrModuleLoad",
+          () => server2.ssrLoadModule(entry)
+        );
         const app = module.default;
         if (!app) {
           throw new Error(`Failed to find a default export from ${entry}.`);
         }
+        const outputChangeSet = await measure(
+          timingsMs,
+          "outputDependencyResolution",
+          async () => module.content?.getOutputChangeSet()
+        );
+        const appFingerprint = await measure(
+          timingsMs,
+          "appFingerprint",
+          () => computeAppFingerprint(config.root, config.configFile)
+        );
+        const outputCachePath = join(
+          config.root,
+          ".riebeckite",
+          "ssg-output-cache.json"
+        );
+        const previousOutputCache = await loadOutputCache(
+          outputCachePath,
+          timingsMs,
+          (message) => this.warn(message)
+        );
+        const siteOwnedOutputPaths = await measure(
+          timingsMs,
+          "siteOwnedOutputs",
+          () => collectSiteOwnedOutputPaths(config.publicDir)
+        );
+        const siteOutputCollisions = findBuildOutputSiteCollisions(
+          Object.keys(bundle),
+          siteOwnedOutputPaths
+        );
+        if (siteOutputCollisions.length > 0) {
+          this.warn(
+            `Build outputs take precedence over site public assets: ${siteOutputCollisions.join(", ")}`
+          );
+        }
+        const canUseIncremental = outputChangeSet && !outputChangeSet.fullRegenerationRequired && previousOutputCache && previousOutputCache.appFingerprint === appFingerprint && outputChangeSet.unchanged.every(
+          (output) => siteOwnedOutputPaths.has(output.path) || previousOutputCache.outputs[output.path]
+        );
+        const reusablePaths = new Set(
+          canUseIncremental ? outputChangeSet.unchanged.map((output) => output.path) : []
+        );
+        const shadowedOutputs = /* @__PURE__ */ new Set();
+        const skippedRouteCount = canUseIncremental ? outputChangeSet.unchanged.filter(
+          (output) => output.kind !== "generated"
+        ).length : 0;
         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 });
+        const nextOutputCache = {
+          version: 1,
+          appFingerprint,
+          outputs: {}
+        };
+        const metrics = {
+          candidateOutputCount: outputChangeSet?.candidateOutputCount ?? 0,
+          affectedOutputCount: outputChangeSet?.affectedOutputCount ?? 0,
+          removedOutputCount: outputChangeSet?.removedOutputCount ?? 0,
+          unchangedOutputCount: outputChangeSet?.unchangedOutputCount ?? 0,
+          renderedOutputCount: 0,
+          emittedOutputCount: 0,
+          reusedOutputCount: 0,
+          deletedOutputCount: 0,
+          shadowedOutputCount: 0,
+          fullRegenerationRequired: !canUseIncremental,
+          htmlOutputCount: 0,
+          assetOutputCount: 0,
+          cacheFileSizeBytes: previousOutputCache?.fileSizeBytes ?? null,
+          cacheEntriesRead: previousOutputCache ? Object.keys(previousOutputCache.outputs).length : 0,
+          cacheEntriesSerialized: 0,
+          enumeratedRouteCount: 0,
+          renderedRouteCount: 0,
+          skippedRouteCount,
+          timingsMs
+        };
+        process.env.RIEBECKITE_SSG_FULL_REGENERATION = canUseIncremental ? "" : "1";
+        const outDir = resolve(config.root, config.build.outDir);
+        const result = await measure(
+          timingsMs,
+          "toSSG",
+          () => toSSG(
+            app,
+            {
+              writeFile: async (filePath, data) => {
+                const fileName = relative(outDir, filePath).replaceAll(
+                  "\\",
+                  "/"
+                );
+                metrics.enumeratedRouteCount += 1;
+                if (siteOwnedOutputPaths.has(fileName)) {
+                  shadowedOutputs.add(fileName);
+                  return;
+                }
+                if (canUseIncremental && reusablePaths.has(fileName)) {
+                  return;
+                }
+                if (fileName.endsWith(".html") && typeof data === "string") {
+                  metrics.renderedOutputCount += 1;
+                  metrics.htmlOutputCount += 1;
+                  generatedHtml.push({ path: fileName, html: data });
+                } else {
+                  metrics.assetOutputCount += 1;
+                }
+                this.emitFile({
+                  type: "asset",
+                  fileName,
+                  source: data
+                });
+                metrics.emittedOutputCount += 1;
+                nextOutputCache.outputs[fileName] = encodeOutput(data);
+              },
+              async mkdir() {
+              }
+            },
+            {
+              dir: outDir,
+              plugins: [...options.plugins ?? []],
+              extensionMap: options.extensionMap ?? defaultExtensionMap
+            }
+          )
+        );
+        delete process.env.RIEBECKITE_SSG_FULL_REGENERATION;
+        metrics.renderedRouteCount = result.files.length;
+        if (!result.success) throw result.error;
+        const emittedGeneratedOutputCount = await measure(
+          timingsMs,
+          "generatedOutputs",
+          () => emitGeneratedOutputs(
+            module,
+            (asset) => {
+              this.emitFile(asset);
+              metrics.emittedOutputCount += 1;
+              nextOutputCache.outputs[asset.fileName] = encodeOutput(
+                asset.source
+              );
+            },
+            canUseIncremental ? new Set(
+              outputChangeSet.affected.filter((output) => output.kind === "generated").map((output) => output.path)
+            ) : void 0,
+            siteOwnedOutputPaths,
+            (path10) => shadowedOutputs.add(path10)
+          )
+        );
+        if (!outputChangeSet)
+          metrics.candidateOutputCount = result.files.length + emittedGeneratedOutputCount;
+        if (canUseIncremental) {
+          await measure(timingsMs, "unchangedOutputReuse", async () => {
+            for (const output of outputChangeSet.unchanged) {
+              const path10 = output.path;
+              if (siteOwnedOutputPaths.has(path10)) {
+                shadowedOutputs.add(path10);
+                continue;
               }
+              const cached = previousOutputCache.outputs[path10];
+              if (!cached) continue;
               this.emitFile({
                 type: "asset",
-                fileName,
-                source: data
+                fileName: path10,
+                source: decodeOutput(cached)
               });
-            },
-            async mkdir() {
+              metrics.emittedOutputCount += 1;
+              metrics.reusedOutputCount += 1;
+              nextOutputCache.outputs[path10] = cached;
             }
-          },
-          {
-            dir: config.build.outDir,
-            plugins: options.plugins ?? [],
-            extensionMap: options.extensionMap ?? defaultExtensionMap
+          });
+        }
+        if (outputChangeSet) {
+          for (const output of outputChangeSet.removed) {
+            if (siteOwnedOutputPaths.has(output.path)) continue;
+            await rm(join(outDir, output.path), {
+              force: true
+            });
+            metrics.deletedOutputCount += 1;
           }
-        );
-        if (!result.success) throw result.error;
-        await emitGeneratedOutputs(module, (asset) => this.emitFile(asset));
+        }
+        metrics.shadowedOutputCount = shadowedOutputs.size;
+        if (shadowedOutputs.size > 0) {
+          this.warn(
+            `Site public assets take precedence over generated outputs: ${[
+              ...shadowedOutputs
+            ].sort().join(", ")}`
+          );
+        }
+        metrics.cacheEntriesSerialized = Object.keys(
+          nextOutputCache.outputs
+        ).length;
+        try {
+          await saveOutputCache(outputCachePath, nextOutputCache, timingsMs);
+        } catch (error) {
+          this.warn(
+            `SSG output cache could not be saved; the next build regenerates every output. ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        await writeSsgOutputMetrics(metrics);
         inspectGeneratedHtmlPages(module, generatedHtml, {
           warn: (message) => this.warn(message),
           info: (message) => this.info(message)
@@ -1130,19 +1609,247 @@ function riebeckiteSsg(options = {}) {
       } finally {
         await server2.close();
       }
+    },
+    async closeBundle() {
+      if (!resolvedConfig) return;
+      const outDir = resolve(resolvedConfig.root, resolvedConfig.build.outDir);
+      const oversizedAssets = await findOversizedAssets(outDir);
+      for (const asset of oversizedAssets) {
+        this.warn(
+          `Generated asset ${asset.path} is ${formatBytes(asset.size)}, exceeding Cloudflare Workers' ${formatBytes(cloudflareWorkerAssetLimit)} asset limit.`
+        );
+      }
     }
   };
 }
-async function emitGeneratedOutputs(module, emit) {
+async function findOversizedAssets(directory, relativeDirectory = "") {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(
+    (error) => {
+      if (isMissingDirectoryError(error)) return [];
+      throw error;
+    }
+  );
+  const nestedAssets = await Promise.all(
+    entries.map(async (entry) => {
+      const path10 = join(directory, entry.name);
+      const relativePath = join(relativeDirectory, entry.name).replaceAll(
+        "\\",
+        "/"
+      );
+      if (entry.isDirectory()) {
+        return findOversizedAssets(path10, relativePath);
+      }
+      if (!entry.isFile()) return [];
+      const size = (await stat(path10)).size;
+      return size > cloudflareWorkerAssetLimit ? [{ path: relativePath, size }] : [];
+    })
+  );
+  return nestedAssets.flat();
+}
+function isMissingDirectoryError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function formatBytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
+function shouldApplyRiebeckiteSsg(_config, env) {
+  return env.command === "build" && env.mode !== "client";
+}
+function findBuildOutputSiteCollisions(buildOutputPaths, siteOwnedOutputPaths) {
+  const collisions = /* @__PURE__ */ new Set();
+  for (const path10 of buildOutputPaths) {
+    if (siteOwnedOutputPaths.has(path10)) collisions.add(path10);
+  }
+  return [...collisions].sort();
+}
+async function emitGeneratedOutputs(module, emit, affectedPaths, shadowedPaths, onShadowed) {
   const content = module.content;
-  if (!content) return;
+  if (!content) return 0;
   const manifest = await content.getManifest();
+  let count = 0;
   for (const output of manifest.generatedOutputs ?? []) {
+    if (affectedPaths && !affectedPaths.has(output.path)) continue;
+    if (shadowedPaths?.has(output.path)) {
+      onShadowed?.(output.path);
+      continue;
+    }
     emit({
       type: "asset",
       fileName: output.path,
       source: output.content
     });
+    count += 1;
+  }
+  return count;
+}
+var APP_FINGERPRINT_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".riebeckite",
+  "dist"
+]);
+var APP_FINGERPRINT_CONFIG_FILES = [
+  "riebeckite.config.ts",
+  "riebeckite.config.mts",
+  "riebeckite.config.cts",
+  "riebeckite.config.js",
+  "riebeckite.config.mjs",
+  "riebeckite.config.cjs"
+];
+async function computeAppFingerprint(root, configFile) {
+  const files = [];
+  await collectAppFiles(join(root, "app"), files);
+  if (configFile) files.push(configFile);
+  for (const name of APP_FINGERPRINT_CONFIG_FILES) {
+    files.push(join(root, name));
+  }
+  files.sort();
+  const hash = createHash("sha256");
+  for (const file of files) {
+    let content;
+    try {
+      content = await readFile(file);
+    } catch {
+      continue;
+    }
+    hash.update(relative(root, file).replaceAll("\\", "/"));
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+async function collectAppFiles(directory, files) {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(
+    () => void 0
+  );
+  if (!entries) return;
+  for (const entry of entries) {
+    const full = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (APP_FINGERPRINT_IGNORED_DIRECTORIES.has(entry.name)) continue;
+      await collectAppFiles(full, files);
+    } else if (entry.isFile()) {
+      files.push(full);
+    }
+  }
+}
+async function loadOutputCache(path10, timingsMs, log = () => {
+}) {
+  let raw;
+  try {
+    raw = await measure(
+      timingsMs,
+      "outputCacheRead",
+      () => readFile(path10, "utf8")
+    );
+  } catch (error) {
+    if (isNotFoundError2(error)) return void 0;
+    log(
+      `SSG output cache could not be read; the build regenerates every output. ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = measureSync(timingsMs, "outputCacheParse", () => JSON.parse(raw));
+  } catch (error) {
+    log(
+      `SSG output cache is corrupted and will be rebuilt. ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+  if (!isOutputCacheState(parsed)) {
+    log("SSG output cache uses an unsupported format and will be rebuilt.");
+    return void 0;
+  }
+  return timingsMs ? { ...parsed, fileSizeBytes: Buffer.byteLength(raw) } : parsed;
+}
+function isOutputCacheState(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.version === 1 && (candidate.appFingerprint === void 0 || typeof candidate.appFingerprint === "string") && isOutputCacheEntries(candidate.outputs);
+}
+function isOutputCacheEntries(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every(
+    (entry) => typeof entry === "object" && entry !== null && typeof entry.source === "string" && (entry.encoding === "utf8" || entry.encoding === "base64")
+  );
+}
+async function saveOutputCache(path10, state, timingsMs) {
+  const directory = dirname(path10);
+  await mkdir(directory, { recursive: true });
+  const temporaryPath = `${path10}.${randomUUID()}.tmp`;
+  const serialized = measureSync(
+    timingsMs,
+    "outputCacheSerialize",
+    () => `${JSON.stringify(state)}
+`
+  );
+  try {
+    await measure(
+      timingsMs,
+      "outputCacheWrite",
+      () => writeFile(temporaryPath, serialized, "utf8")
+    );
+    await measure(
+      timingsMs,
+      "outputCacheRename",
+      () => replaceFile(temporaryPath, path10)
+    );
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function replaceFile(temporaryPath, targetPath) {
+  try {
+    await rename2(temporaryPath, targetPath);
+  } catch (error) {
+    if (!isReplacementFailure(error)) throw error;
+    await rm(targetPath, { force: true });
+    await rename2(temporaryPath, targetPath);
+  }
+}
+function isReplacementFailure(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return false;
+  }
+  const code = String(error.code);
+  return code === "EPERM" || code === "EEXIST" || code === "EACCES";
+}
+function isNotFoundError2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function encodeOutput(source) {
+  return typeof source === "string" ? { source, encoding: "utf8" } : { source: Buffer.from(source).toString("base64"), encoding: "base64" };
+}
+function decodeOutput(entry) {
+  return entry.encoding === "utf8" ? entry.source : Buffer.from(entry.source, "base64");
+}
+async function writeSsgOutputMetrics(metrics) {
+  const file = process.env.RIEBECKITE_SSG_METRICS_FILE;
+  if (!file) return;
+  await writeFile(file, `${JSON.stringify(metrics)}
+`, "utf8");
+}
+async function measure(timingsMs, name, fn) {
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    if (timingsMs)
+      timingsMs[name] = (timingsMs[name] ?? 0) + performance.now() - start;
+  }
+}
+function measureSync(timingsMs, name, fn) {
+  const start = performance.now();
+  try {
+    return fn();
+  } finally {
+    if (timingsMs)
+      timingsMs[name] = (timingsMs[name] ?? 0) + performance.now() - start;
   }
 }
 function inspectGeneratedHtmlPages(module, pages, log) {
@@ -1192,8 +1899,8 @@ function createRiebeckiteSsg(options = {}) {
 }
 
 // src/vite_runner.ts
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
 import { build, createServer as createServer2 } from "vite";
 var viteConfigFileNames = [
   "vite.config.ts",
@@ -1219,8 +1926,8 @@ var HonoxApplicationRootError = class extends Error {
   }
 };
 async function resolveHonoxApplication(options) {
-  const configRoot = path5.resolve(options.configRoot);
-  const appRoot = options.appRoot ? path5.resolve(options.appRoot) : await resolveHonoxApplicationRoot(configRoot);
+  const configRoot = path7.resolve(options.configRoot);
+  const appRoot = options.appRoot ? path7.resolve(options.appRoot) : await resolveHonoxApplicationRoot(configRoot);
   const workspaceRoot = options.workspaceRoot ?? await findWorkspaceRoot(configRoot);
   const rawConfig = await loadRiebeckiteConfig({
     configRoot,
@@ -1237,8 +1944,8 @@ async function resolveHonoxApplication(options) {
 }
 async function findWorkspaceRoot(configRoot) {
   try {
-    const workspaceConfig = path5.join(configRoot, "pnpm-workspace.yaml");
-    return (await fs5.stat(workspaceConfig)).isFile() ? configRoot : void 0;
+    const workspaceConfig = path7.join(configRoot, "pnpm-workspace.yaml");
+    return (await fs6.stat(workspaceConfig)).isFile() ? configRoot : void 0;
   } catch {
     return void 0;
   }
@@ -1265,9 +1972,9 @@ async function runTraced(tracer, name, buildTask) {
   return tracer ? await tracer.span(name, {}, buildTask) : await buildTask();
 }
 async function waitForShutdown(server2) {
-  await new Promise((resolve) => {
+  await new Promise((resolve2) => {
     const close = () => {
-      void server2.close().finally(resolve);
+      void server2.close().finally(resolve2);
     };
     process.once("SIGINT", close);
     process.once("SIGTERM", close);
@@ -1280,12 +1987,12 @@ async function findViteApplicationRoots(root) {
     const directory = directories.pop();
     if (!directory) continue;
     if (await hasViteConfig(directory)) applicationRoots.push(directory);
-    const entries = await fs5.readdir(directory, { withFileTypes: true });
+    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(path5.join(directory, entry.name));
+      directories.push(path7.join(directory, entry.name));
     }
   }
   return applicationRoots;
@@ -1293,7 +2000,7 @@ async function findViteApplicationRoots(root) {
 async function hasViteConfig(directory) {
   for (const fileName of viteConfigFileNames) {
     try {
-      if ((await fs5.stat(path5.join(directory, fileName))).isFile()) return true;
+      if ((await fs6.stat(path7.join(directory, fileName))).isFile()) return true;
     } catch {
     }
   }
@@ -1313,6 +2020,7 @@ var defaultSsrExternals = [
 ];
 function riebeckite(options = {}) {
   let resolvedConfig;
+  let contentWatchRoots;
   const getConfig = () => {
     if (!resolvedConfig) {
       throw new Error("Riebeckite config has not been loaded yet.");
@@ -1323,7 +2031,7 @@ function riebeckite(options = {}) {
     {
       name: "riebeckite-host-integration",
       async config(userConfig) {
-        const root = userConfig.root ? path6.resolve(userConfig.root) : process.cwd();
+        const root = userConfig.root ? path8.resolve(userConfig.root) : process.cwd();
         const appRoot = options.appRoot ?? root;
         const application = await resolveHonoxApplication({
           configRoot: options.configRoot ?? appRoot,
@@ -1332,9 +2040,10 @@ function riebeckite(options = {}) {
           workspaceRoot: options.workspaceRoot
         });
         resolvedConfig = application.config;
+        contentWatchRoots = application;
         writeRiebeckiteAssetEntries(resolvedConfig, {
-          pluginStyles: path6.join(appRoot, "app/.riebeckite/plugin-styles.css"),
-          themeStyles: path6.join(appRoot, "app/.riebeckite/theme-styles.css")
+          pluginStyles: path8.join(appRoot, "app/.riebeckite/plugin-styles.css"),
+          themeStyles: path8.join(appRoot, "app/.riebeckite/theme-styles.css")
         });
         return {
           define: {
@@ -1351,9 +2060,24 @@ function riebeckite(options = {}) {
         };
       }
     },
-    riebeckiteClientModule(getConfig)
+    riebeckiteClientModule(getConfig),
+    riebeckiteContentAssets({
+      appRoot: () => requireContentWatchRoots(contentWatchRoots).appRoot,
+      contentRoot: () => requireContentWatchRoots(contentWatchRoots).contentRoot
+    }),
+    riebeckiteContentWatch({
+      appRoot: () => requireContentWatchRoots(contentWatchRoots).appRoot,
+      contentRoot: () => requireContentWatchRoots(contentWatchRoots).contentRoot,
+      exclude: () => getConfig().content.exclude ?? []
+    })
   ];
 }
+function requireContentWatchRoots(roots) {
+  if (!roots) {
+    throw new Error("Riebeckite application has not been resolved yet.");
+  }
+  return roots;
+}
 function riebeckiteVite(options = {}) {
   const { ssg, ssrExternals, ...integration } = options;
   return [
@@ -1380,6 +2104,17 @@ function riebeckiteSsrExternals(externals) {
 }
 
 // src/scaffold/app-templates.ts
+function hasScaffoldPlugin(preset, packageName) {
+  return preset.plugins.some((plugin) => plugin.package === packageName);
+}
+function articleTitleHelper() {
+  return `
+function getArticleTitle(slug: string, title: unknown): string {
+  if (typeof title === "string" && title.trim().length > 0) return title;
+  return slug.split("/").at(-1) ?? slug;
+}
+`;
+}
 function server() {
   return `import { mountRiebeckiteEndpoints } from "@riebeckite/honox/server";
 import { createApp } from "honox/server";
@@ -1532,6 +2267,56 @@ function style(preset) {
       "  padding: 2rem 1rem;",
       "  margin: 0 auto;",
       "}",
+      "",
+      ".article-shell__layout {",
+      "  display: grid;",
+      "  grid-template-columns: minmax(0, 1fr);",
+      "  justify-content: center;",
+      "  gap: var(--rb-layout-gap, 2rem);",
+      "}",
+      "",
+      ".site-article__aside {",
+      "  display: none;",
+      "}",
+      "",
+      ".site-article__footer {",
+      "  min-width: 0;",
+      "}",
+      "",
+      "@media (min-width: 88rem) {",
+      '  :is(:root, .rb-theme-root)[data-article-layout="article"] .article-shell__layout {',
+      "    grid-template-columns: minmax(0, var(--rb-layout-article-max, 48rem));",
+      "    position: relative;",
+      "  }",
+      "",
+      '  :is(:root, .rb-theme-root)[data-article-layout="article"] .article-shell__body {',
+      "    grid-column: 1;",
+      "    grid-row: 1;",
+      "  }",
+      "",
+      '  :is(:root, .rb-theme-root)[data-article-layout="article"] .site-article__footer {',
+      "    grid-column: 1;",
+      "  }",
+      "",
+      '  :is(:root, .rb-theme-root)[data-article-layout="article"] .site-article__aside {',
+      "    display: block;",
+      "    grid-column: 1;",
+      "    grid-row: 1;",
+      "    position: sticky;",
+      "    top: 4rem;",
+      "    align-self: start;",
+      "    width: var(--rb-layout-sidebar, 14rem);",
+      "    max-height: calc(100dvh - 8rem);",
+      "    margin-inline-start: calc(",
+      "      -1 * var(--rb-layout-sidebar, 14rem) -",
+      "      var(--rb-layout-gap, 2rem)",
+      "    );",
+      "    overflow: auto;",
+      "    padding-inline-end: 1rem;",
+      "    border-inline-end: 1px solid",
+      "      color-mix(in oklab, currentColor 18%, transparent);",
+      "  }",
+      "}",
       ""
     );
   }
@@ -1576,23 +2361,81 @@ import { Article, ArticleContent, ArticleLayout } from "@riebeckite/honox/ui";
 
 export function SiteArticle({
   post,
-  afterMeta,
+  propertiesHtml,
+  afterHeaderHtml,
+  afterMetaHtml,
+  beforeContentHtml,
+  afterContentHtml,
+  asideHtml,
+  footerHtml,
+  asideContent,
+  afterContent,
+  footerContent,
 }: {
   post: PostContent;
-  afterMeta?: string;
+  propertiesHtml?: string;
+  afterHeaderHtml?: string;
+  afterMetaHtml?: string;
+  beforeContentHtml?: string;
+  afterContentHtml?: string;
+  asideHtml?: string;
+  footerHtml?: string;
+  asideContent?: unknown;
+  afterContent?: unknown;
+  footerContent?: unknown;
 }) {
   return (
     <Article class="site-article">
       <ArticleLayout>
+        {asideContent}
+        {asideHtml ? (
+          <div
+            class="site-article__aside"
+            dangerouslySetInnerHTML={{ __html: asideHtml }}
+          />
+        ) : null}
         <ArticleContent>
-          {afterMeta ? (
+          {afterHeaderHtml ? (
+            <div
+              class="site-article__after-header"
+              dangerouslySetInnerHTML={{ __html: afterHeaderHtml }}
+            />
+          ) : null}
+          {propertiesHtml ? (
+            <div
+              class="article-properties"
+              dangerouslySetInnerHTML={{ __html: propertiesHtml }}
+            />
+          ) : null}
+          {afterMetaHtml ? (
             <div
               class="site-article__after-meta"
-              dangerouslySetInnerHTML={{ __html: afterMeta }}
+              dangerouslySetInnerHTML={{ __html: afterMetaHtml }}
+            />
+          ) : null}
+          {beforeContentHtml ? (
+            <div
+              class="site-article__before-content"
+              dangerouslySetInnerHTML={{ __html: beforeContentHtml }}
             />
           ) : null}
           <div dangerouslySetInnerHTML={{ __html: post.html ?? "" }} />
+          {afterContent}
+          {afterContentHtml ? (
+            <div
+              class="site-article__after-content"
+              dangerouslySetInnerHTML={{ __html: afterContentHtml }}
+            />
+          ) : null}
         </ArticleContent>
+        {footerHtml || footerContent ? (
+          <div class="site-article__footer">
+            {footerHtml ? (
+              <div dangerouslySetInnerHTML={{ __html: footerHtml }} />
+            ) : null}
+            {footerContent}
+          </div>
+        ) : null}
       </ArticleLayout>
     </Article>
   );
@@ -1605,10 +2448,12 @@ function renderer(preset) {
   const hasColorMode = preset.plugins.some(
     (plugin) => plugin.package === "@riebeckite/plugin-color-mode"
   );
+  const hasSearch = hasScaffoldPlugin(preset, "@riebeckite/plugin-search");
   return `import type { PluginHeadTag } from "@riebeckite/core";
 import { jsxRenderer } from "hono/jsx-renderer";
 import { Link, Script } from "honox/server";
 ${hasColorMode ? `import { ColorModeScript } from "@riebeckite/plugin-color-mode";
+` : ""}${hasSearch ? `import { SearchBar } from "@riebeckite/plugin-search";
 ` : ""}${hasHeader ? `import { SiteHeader } from "../components/site-header";
 ` : ""}import { config } from "../config";
 
@@ -1648,6 +2493,7 @@ ${hasColorMode ? `        <ColorModeScript />
       </head>
       <body class="riebeckite-page">
 ${hasHeader ? `        <SiteHeader />
+` : ""}${hasSearch ? `        <SearchBar />
 ` : ""}        {children}
       </body>
     </html>
@@ -1696,11 +2542,96 @@ export default jsxRenderer(({ children }, c) => (
 }
 function indexRoute(preset) {
   if (!preset.appFiles.includes("article")) return staticIndexRoute();
-  return `import { isPublished } from "@riebeckite/core";
-import { createRoute } from "honox/factory";
-import { SiteArticle } from "../components/article";
-import { config } from "../config";
-import { content } from "../content";
+  const hasToc = hasScaffoldPlugin(preset, "@riebeckite/plugin-toc");
+  const hasBacklinks = hasScaffoldPlugin(
+    preset,
+    "@riebeckite/plugin-backlinks"
+  );
+  const hasRecentPosts = hasScaffoldPlugin(
+    preset,
+    "@riebeckite/plugin-recent-posts"
+  );
+  const hasDailyNotes = hasScaffoldPlugin(
+    preset,
+    "@riebeckite/plugin-daily-notes"
+  );
+  const needsTitle = hasBacklinks || hasRecentPosts;
+  const needsConfig = hasBacklinks || hasRecentPosts || hasDailyNotes;
+  const importLines = [
+    'import { createRoute } from "honox/factory";'
+  ];
+  if (hasBacklinks) {
+    importLines.push(
+      'import { Backlinks, getPublishedBacklinks } from "@riebeckite/plugin-backlinks";'
+    );
+  }
+  if (hasDailyNotes) {
+    importLines.push(
+      'import { DailyNotes, getDailyNotes } from "@riebeckite/plugin-daily-notes";'
+    );
+  }
+  if (hasRecentPosts) {
+    importLines.push(
+      'import { RecentPosts, getRecentPosts } from "@riebeckite/plugin-recent-posts";'
+    );
+  }
+  if (hasToc) {
+    importLines.push(
+      'import { extractTableOfContents, TableOfContents } from "@riebeckite/plugin-toc";'
+    );
+  }
+  importLines.push('import { SiteArticle } from "../components/article";');
+  if (needsConfig) importLines.push('import { config } from "../config";');
+  importLines.push('import { content } from "../content";');
+  const dataLines = [];
+  if (hasBacklinks) {
+    dataLines.push(
+      '  const backlinks = getPublishedBacklinks({ manifest, config, slug: "index", resolveTitle: getArticleTitle });'
+    );
+  }
+  if (hasRecentPosts) {
+    dataLines.push(
+      "  const recentPosts = await getRecentPosts({ posts: manifest.discoverableEntries, config, getProcessedContent: (slug) => content.getProcessedContent(slug), resolveTitle: getArticleTitle });"
+    );
+  }
+  if (hasDailyNotes) {
+    dataLines.push("  const dailyNotes = getDailyNotes({ manifest, config });");
+  }
+  if (hasToc) {
+    dataLines.push(
+      '  const tableOfContents = extractTableOfContents(post.html ?? "");'
+    );
+  }
+  const propLines = [
+    "        propertiesHtml={indexEntry?.bodySlots?.properties}",
+    '        afterHeaderHtml={indexEntry?.bodySlots?.["article.after-header"]}',
+    '        afterMetaHtml={indexEntry?.bodySlots?.["article.after-meta"]}',
+    '        beforeContentHtml={indexEntry?.bodySlots?.["article.before-content"]}',
+    '        afterContentHtml={indexEntry?.bodySlots?.["article.after-content"]}',
+    '        asideHtml={indexEntry?.bodySlots?.["article.aside"]}',
+    '        footerHtml={indexEntry?.bodySlots?.["article.footer"]}'
+  ];
+  if (hasToc) {
+    propLines.push(
+      '        asideContent={<TableOfContents className="table-of-contents--desktop" items={tableOfContents} />}'
+    );
+  }
+  const afterChildren = [];
+  if (hasRecentPosts) afterChildren.push("<RecentPosts posts={recentPosts} />");
+  if (hasDailyNotes) afterChildren.push("<DailyNotes notes={dailyNotes} />");
+  if (afterChildren.length > 0) {
+    propLines.push(`        afterContent={<>${afterChildren.join("")}</>}`);
+  }
+  if (hasBacklinks) {
+    propLines.push(
+      "        footerContent={<Backlinks backlinks={backlinks} />}"
+    );
+  }
+  const titleHelper = needsTitle ? articleTitleHelper() : "";
+  const dataBlock = dataLines.length > 0 ? `
+${dataLines.join("\n")}
+` : "";
+  return `${importLines.join("\n")}
 
 export default createRoute(async (c) => {
   const manifest = await content.getManifest();
@@ -1710,10 +2641,10 @@ export default createRoute(async (c) => {
   }
 
   const post = await content.getProcessedContent("index");
-  if (!isPublished(config, post.frontmatter)) {
+  if (indexEntry?.publishing?.routable === false) {
     return c.notFound();
   }
-
+${dataBlock}
   if (indexEntry) {
     c.set("htmlLanguage", indexEntry.publicLocation.metadata?.["l10n.lang"]);
     c.set("headTags", indexEntry.headTags ?? []);
@@ -1722,11 +2653,10 @@ export default createRoute(async (c) => {
   return c.render(
     <SiteArticle
       post={post}
-      afterMeta={indexEntry?.bodySlots?.["article.after-meta"]}
+${propLines.join("\n")}
     />,
   );
-});
-`;
+});${titleHelper}`;
 }
 function staticIndexRoute() {
   return `import { createRoute } from "honox/factory";
@@ -1742,23 +2672,98 @@ export default createRoute((c) =>
 );
 `;
 }
-function slugRoute() {
-  return `import { isPublished } from "@riebeckite/core";
-import {
-  contentRouteSsgParams,
-  pluginPageSsgParams,
-  resolveRiebeckiteRoute,
-} from "@riebeckite/honox/server";
-import { createRoute } from "honox/factory";
-import { SiteArticle } from "../components/article";
-import { config } from "../config";
-import { content } from "../content";
+function slugRoute(preset) {
+  const hasToc = hasScaffoldPlugin(preset, "@riebeckite/plugin-toc");
+  const hasBacklinks = hasScaffoldPlugin(
+    preset,
+    "@riebeckite/plugin-backlinks"
+  );
+  const hasLocalGraph = hasScaffoldPlugin(
+    preset,
+    "@riebeckite/plugin-local-graph"
+  );
+  const needsTitle = hasBacklinks || hasLocalGraph;
+  const needsConfig = hasBacklinks || hasLocalGraph;
+  const needsManifest = hasBacklinks || hasLocalGraph;
+  const importLines = [
+    "import {",
+    "  contentRouteSsgParams,",
+    "  pluginPageSsgParams,",
+    "  resolveRiebeckiteRoute,",
+    '} from "@riebeckite/honox/server";'
+  ];
+  if (hasBacklinks) {
+    importLines.push(
+      'import { Backlinks, getPublishedBacklinks } from "@riebeckite/plugin-backlinks";'
+    );
+  }
+  if (hasLocalGraph) {
+    importLines.push(
+      'import { LocalGraph, getLocalGraph } from "@riebeckite/plugin-local-graph";'
+    );
+  }
+  if (hasToc) {
+    importLines.push(
+      'import { extractTableOfContents, TableOfContents } from "@riebeckite/plugin-toc";'
+    );
+  }
+  importLines.push('import { createRoute } from "honox/factory";');
+  importLines.push('import { SiteArticle } from "../components/article";');
+  if (needsConfig) importLines.push('import { config } from "../config";');
+  importLines.push('import { content } from "../content";');
+  const dataLines = [];
+  if (needsManifest) {
+    dataLines.push("    const manifest = await content.getManifest();");
+  }
+  if (hasBacklinks) {
+    dataLines.push(
+      "    const backlinks = getPublishedBacklinks({ manifest, config, slug: route.entry.slug, resolveTitle: getArticleTitle });"
+    );
+  }
+  if (hasLocalGraph) {
+    dataLines.push(
+      "    const localGraph = getLocalGraph({ manifest, config, slug: route.entry.slug, resolveTitle: getArticleTitle });"
+    );
+  }
+  if (hasToc) {
+    dataLines.push(
+      '    const tableOfContents = extractTableOfContents(post.html ?? "");'
+    );
+  }
+  const propLines = [
+    "        propertiesHtml={route.entry.bodySlots?.properties}",
+    '        afterHeaderHtml={route.entry.bodySlots?.["article.after-header"]}',
+    '        afterMetaHtml={route.entry.bodySlots?.["article.after-meta"]}',
+    '        beforeContentHtml={route.entry.bodySlots?.["article.before-content"]}',
+    '        afterContentHtml={route.entry.bodySlots?.["article.after-content"]}',
+    '        asideHtml={route.entry.bodySlots?.["article.aside"]}',
+    '        footerHtml={route.entry.bodySlots?.["article.footer"]}'
+  ];
+  if (hasToc) {
+    propLines.push(
+      '        asideContent={<TableOfContents className="table-of-contents--desktop" items={tableOfContents} />}'
+    );
+  }
+  const footerChildren = [];
+  if (hasLocalGraph) {
+    footerChildren.push("{localGraph && <LocalGraph graph={localGraph} />}");
+  }
+  if (hasBacklinks) {
+    footerChildren.push("<Backlinks backlinks={backlinks} />");
+  }
+  if (footerChildren.length > 0) {
+    propLines.push(`        footerContent={<>${footerChildren.join("")}</>}`);
+  }
+  const titleHelper = needsTitle ? articleTitleHelper() : "";
+  const dataBlock = dataLines.length > 0 ? `
+${dataLines.join("\n")}
+` : "";
+  return `${importLines.join("\n")}
 
 export default createRoute(
   contentRouteSsgParams("/:slug{.+}", async () => {
     const manifest = await content.getManifest();
-    const contentPaths = manifest.entries
-      .filter((entry) => isPublished(config, entry.frontmatter))
+    const contentPaths = manifest.publicEntries
       .filter((entry) => entry.permalink !== "/")
       .map((entry) => ({ slug: entry.permalink.replace(/^\\/+/, "") }));
     return [...contentPaths, ...(await pluginPageSsgParams(content))];
@@ -1780,22 +2785,18 @@ export default createRoute(
     }
 
     const post = await content.getProcessedContent(route.entry.slug);
-    if (!isPublished(config, post.frontmatter)) {
-      return c.notFound();
-    }
-
+${dataBlock}
     c.set("htmlLanguage", route.entry.publicLocation.metadata?.["l10n.lang"]);
     c.set("headTags", route.entry.headTags ?? []);
 
     return c.render(
       <SiteArticle
         post={post}
-        afterMeta={route.entry.bodySlots?.["article.after-meta"]}
+${propLines.join("\n")}
       />,
     );
   },
-);
-`;
+);${titleHelper}`;
 }
 
 // src/scaffold/localized-content.ts
@@ -2160,7 +3161,7 @@ function localizedContentFiles(variables, preset) {
         (language) => themesContent(language, preset)
       );
     } else if (page === "guide") {
-      pushEnglishOnly("guide", guideContent);
+      pushEnglishOnly("guide", () => guideContent(preset));
     } else if (page === "examples") {
       pushLocalized(
         "examples",
@@ -2354,10 +3355,50 @@ var INDEX = {
     de: "Übersetzte Seiten folgen der Konvention `<base>.<lang>.md` neben der Standarddatei (z. B. `about.ja.md`). Das l10n-Plugin liefert sie unter `/lang/`-Pfaden und verlinkt sie automatisch.",
     fr: "Les pages localisées suivent la convention `<base>.<lang>.md` à côté du fichier par défaut (ex. `about.ja.md`). Le plugin l10n les sert sous des chemins `/lang/` et les relie automatiquement.",
     ko: "번역 페이지는 기본 파일 옆에 `<base>.<lang>.md` 규칙으로 둡니다(예: `about.ja.md`). l10n 플러그인이 `/lang/` 경로로 서빙하며 자동으로 링크합니다."
+  },
+  editFileNote: {
+    en: "This page is `content/index.md`. Open that file, change it, and save — the browser updates while you write.",
+    ja: "このページは `content/index.md` です。ファイルを開いて書き換えると、書いている途中でもブラウザの表示が更新されます。",
+    "zh-CN": "这个页面来自 `content/index.md`。打开这个文件修改并保存，浏览器会随你的输入更新。",
+    es: "Esta página viene de `content/index.md`. Abre ese archivo, edítalo y guarda: el navegador se actualiza mientras escribes.",
+    de: "Diese Seite stammt aus `content/index.md`. Öffne die Datei, ändere sie und speichere — der Browser aktualisiert sich beim Schreiben.",
+    fr: "Cette page provient de `content/index.md`. Ouvrez ce fichier, modifiez-le et enregistrez — le navigateur se met à jour pendant que vous écrivez.",
+    ko: "이 페이지는 `content/index.md`에서 만들어집니다. 그 파일을 열어 수정하고 저장하면 글을 쓰는 동안 브라우저가 갱신됩니다."
+  },
+  linkLine: {
+    en: "Link pages with a WikiLink, for example `[[guide]]`.",
+    ja: "ページ同士は WikiLink でリンクできます（例：`[[guide]]`）。",
+    "zh-CN": "用 WikiLink 连接页面，例如 `[[guide]]`。",
+    es: "Enlaza páginas con un WikiLink, por ejemplo `[[guide]]`.",
+    de: "Verbinde Seiten mit einem WikiLink, zum Beispiel `[[guide]]`.",
+    fr: "Reliez les pages avec un WikiLink, par exemple `[[guide]]`.",
+    ko: "WikiLink로 페이지를 연결하세요. 예: `[[guide]]`."
   }
 };
+function starterIndexContent(title, language) {
+  return [
+    frontmatter(),
+    heading(1, title),
+    "",
+    read(INDEX.lead, language),
+    "",
+    read(INDEX.editFileNote, language),
+    "",
+    heading(2, read(INDEX.editHeading, language)),
+    read(INDEX.editLead, language),
+    "",
+    read(INDEX.linkLine, language),
+    "",
+    heading(2, read(INDEX.exploreHeading, language)),
+    "",
+    "- [Getting started](/guide)",
+    "- [[examples]]",
+    ""
+  ].join("\n");
+}
 function indexContent(variables, preset, language) {
   const title = variables.title;
+  if (preset.name === "starter") return starterIndexContent(title, language);
   return [
     frontmatter(),
     heading(1, title),
@@ -2371,10 +3412,6 @@ function indexContent(variables, preset, language) {
       `- [${read(INDEX.exploreThemes, language)}](/framework/themes)`,
       "- [Working examples](/examples/)",
       "- [Plugin reference](/reference/plugins/)"
-    ] : preset.name === "starter" ? [
-      heading(2, read(INDEX.exploreHeading, language)),
-      "- [Getting started](/guide/)",
-      "- [Example notes](/examples/)"
     ] : [],
     heading(2, read(INDEX.editHeading, language)),
     read(INDEX.editLead, language),
@@ -2426,7 +3463,7 @@ var THEMES_COPY = {
     es: "Este starter usa `@riebeckite/theme-default`. Para probar otro tema:",
     de: "Dieser Starter verwendet `@riebeckite/theme-default`. Um ein anderes Theme zu testen:",
     fr: "Ce starter utilise `@riebeckite/theme-default`. Pour essayer un autre thème :",
-    ko: "이 스타터는 `@riebeckite/theme-default`를 사용합니다. 다른 테마를 시도하려면："
+    ko: "이 스타터는 `@riebeckite/theme-default`를 사용합니다. 다른 테마를 시도하려면:"
   },
   switchStep1: {
     en: "Install the package:",
@@ -2435,7 +3472,7 @@ var THEMES_COPY = {
     es: "Instala el paquete:",
     de: "Installiere das Paket:",
     fr: "Installez le paquet :",
-    ko: "패키지를 설치합니다："
+    ko: "패키지를 설치합니다:"
   },
   switchStep2: {
     en: "Point `theme` at the new factory in `riebeckite.config.ts`:",
@@ -2444,7 +3481,7 @@ var THEMES_COPY = {
     es: "Apunta `theme` al nuevo factory en `riebeckite.config.ts`:",
     de: "Setze `theme` in `riebeckite.config.ts` auf den neuen Factory:",
     fr: "Pointez `theme` vers le nouveau factory dans `riebeckite.config.ts` :",
-    ko: "`riebeckite.config.ts`의 `theme`를 새 팩토리로 변경합니다："
+    ko: "`riebeckite.config.ts`의 `theme`를 새 팩토리로 변경합니다:"
   },
   tableHeading: {
     en: "The bundled themes",
@@ -2664,7 +3701,7 @@ var PLUGINS_COPY = {
     es: "Instala el paquete:",
     de: "Installiere das Paket:",
     fr: "Installez le paquet :",
-    ko: "패키지를 설치합니다："
+    ko: "패키지를 설치합니다:"
   },
   installStep2: {
     en: "Register it in the `plugins` array of `riebeckite.config.ts`:",
@@ -2673,7 +3710,7 @@ var PLUGINS_COPY = {
     es: "Regístralo en el array `plugins` de `riebeckite.config.ts`:",
     de: "Registriere es im `plugins`-Array der `riebeckite.config.ts`:",
     fr: "Enregistrez-le dans le tableau `plugins` de `riebeckite.config.ts` :",
-    ko: "`riebeckite.config.ts`의 `plugins` 배열에 등록합니다："
+    ko: "`riebeckite.config.ts`의 `plugins` 배열에 등록합니다:"
   },
   fullList: {
     en: "The complete plugin index lives in the repository:",
@@ -2682,7 +3719,7 @@ var PLUGINS_COPY = {
     es: "El índice completo de plugins vive en el repositorio:",
     de: "Der vollständige Plugin-Index liegt im Repository:",
     fr: "L'index complet des plugins se trouve dans le dépôt :",
-    ko: "전체 플러그인 목록은 저장소에 있습니다："
+    ko: "전체 플러그인 목록은 저장소에 있습니다:"
   },
   fullListLabel: {
     en: "Riebeckite plugins on GitHub",
@@ -3188,7 +4225,65 @@ function pluginsContent(language) {
   lines.push("");
   return lines.join("\n");
 }
-function guideContent() {
+function starterGuideContent() {
+  return [
+    frontmatter(),
+    heading(1, "Getting started"),
+    "",
+    "This site was generated from a Riebeckite scaffold preset.",
+    "Everything below lives in this repository, ready to edit.",
+    "",
+    heading(2, "Run the site"),
+    "",
+    codeBlock("sh", ["npm install", "npm exec riebeckite dev"].join("\n")),
+    "",
+    "Open the URL printed in the terminal. The page reloads every time",
+    "you save a Markdown file.",
+    "",
+    heading(2, "Add a page"),
+    "",
+    "Create `content/hello.md`:",
+    "",
+    codeBlock(
+      "md",
+      [
+        "---",
+        "publish: true",
+        "---",
+        "",
+        "# Hello",
+        "",
+        "This is my second page."
+      ].join("\n")
+    ),
+    "",
+    "The dev server serves it at `/hello`.",
+    "",
+    heading(2, "Link the pages"),
+    "",
+    "Write `[[hello]]` anywhere and it becomes a link to that page.",
+    "",
+    heading(2, "Translate a page"),
+    "",
+    "Copy a file next to the original with the language suffix, for",
+    "example `hello.ja.md`. The language switcher picks it up.",
+    "",
+    heading(2, "Build"),
+    "",
+    codeBlock("sh", "npm exec riebeckite build"),
+    "",
+    "The static site is written to `dist/`.",
+    "",
+    heading(2, "Extend"),
+    "",
+    "Plugins and themes are registered in `riebeckite.config.ts`.",
+    "Install a package, import its factory, and add it to the `plugins`",
+    "array, or point `theme` at a new theme factory.",
+    ""
+  ].join("\n");
+}
+function guideContent(preset) {
+  if (preset.name !== "showcase") return starterGuideContent();
   return [
     frontmatter(),
     heading(1, "Getting started"),
@@ -3213,9 +4308,9 @@ function guideContent() {
     codeBlock(
       "sh",
       [
-        "pnpm install",
-        "pnpm exec riebeckite dev",
-        "pnpm exec riebeckite build"
+        "npm install",
+        "npm exec riebeckite dev",
+        "npm exec riebeckite build"
       ].join("\n")
     ),
     "",
@@ -3253,7 +4348,77 @@ var SHOWCASE_GUIDE_DEMOS = [
   "@riebeckite/plugin-canvas",
   "@riebeckite/plugin-flashcards"
 ];
+var STARTER_EXAMPLES = {
+  heading: {
+    en: "Example",
+    ja: "サンプル"
+  },
+  intro: {
+    en: "A small page showing what Riebeckite Markdown can do. Copy any section into your own files.",
+    ja: "Riebeckite の Markdown でできることをまとめた小さなページです。必要なセクションを自分のファイルにコピーできます。"
+  },
+  linksHeading: {
+    en: "Links",
+    ja: "リンク"
+  },
+  linksBody: {
+    en: "WikiLinks connect pages: [[guide]] opens Getting started. Regular Markdown links work as well — [Home](/) returns to the home page.",
+    ja: "WikiLink でページをつなげます：[[guide]] は Getting started を開きます。通常の Markdown リンクも使えます — [Home](/) でホームに戻れます。"
+  },
+  codeHeading: {
+    en: "Code",
+    ja: "コード"
+  },
+  codeIntro: {
+    en: "A fenced code block keeps its formatting and gains a toolbar from the code plugins:",
+    ja: "フェンス付きコードブロックは書式を保ったまま表示され、コード系プラグインでツールバーが付きます："
+  },
+  frontmatterHeading: {
+    en: "Frontmatter",
+    ja: "フロントマター"
+  },
+  frontmatterBody: {
+    en: "The block between the `---` lines at the top of a file controls the page. `publish: true` keeps it in the built site:",
+    ja: "ファイル先頭の `---` に挟まれた部分がページを制御します。`publish: true` を書き続けるとビルド対象に残ります："
+  }
+};
+function starterExamplesContent(language) {
+  return [
+    frontmatter(),
+    heading(1, readSummary(STARTER_EXAMPLES.heading, language)),
+    "",
+    readSummary(STARTER_EXAMPLES.intro, language),
+    "",
+    heading(2, readSummary(STARTER_EXAMPLES.linksHeading, language)),
+    "",
+    readSummary(STARTER_EXAMPLES.linksBody, language),
+    "",
+    heading(2, readSummary(STARTER_EXAMPLES.codeHeading, language)),
+    "",
+    readSummary(STARTER_EXAMPLES.codeIntro, language),
+    "",
+    codeBlock(
+      "ts",
+      [
+        "export function hello(): string {",
+        '  return "Hello from Riebeckite";',
+        "}"
+      ].join("\n")
+    ),
+    "",
+    heading(2, readSummary(STARTER_EXAMPLES.frontmatterHeading, language)),
+    "",
+    readSummary(STARTER_EXAMPLES.frontmatterBody, language),
+    "",
+    codeBlock(
+      "yaml",
+      ["---", "publish: true", "title: Example", "---"].join("\n")
+    ),
+    ""
+  ].join("\n");
+}
 function examplesContent(preset, language) {
+  if (preset.name === "starter") return starterExamplesContent(language);
   const lines = [
     frontmatter(),
     heading(1, readSummary(EXAMPLES_COPY.heading, language)),
@@ -3308,7 +4473,7 @@ function referencePluginsContent(preset, variables) {
     "Every registered plugin is listed below with the Markdown that triggers it,",
     "or with the Markdown/frontmatter/content shape it reads when the plugin is",
     "site-wide rather than block-based. Paste the examples into files under",
-    "`content/` and run `pnpm exec riebeckite dev` to inspect the rendered result.",
+    "`content/` and run `npm exec riebeckite dev` to inspect the rendered result.",
     ""
   );
   for (const plugin of preset.plugins) {
@@ -3373,7 +4538,7 @@ function referenceThemesContent(preset) {
 }
 
 // src/scaffold/version.ts
-var RIEBECKITE_VERSION = "^0.0.13";
+var RIEBECKITE_VERSION = "^0.0.15";
 
 // src/scaffold/templates.ts
 function siteTemplateFiles(preset, variables) {
@@ -3403,7 +4568,7 @@ function readPackageAsset(fileName) {
     new URL(`../assets/${fileName}`, import.meta.url)
   ];
   for (const candidate of candidates) {
-    if (fs6.existsSync(candidate)) return fs6.readFileSync(candidate);
+    if (fs7.existsSync(candidate)) return fs7.readFileSync(candidate);
   }
   throw new Error(`Missing Riebeckite scaffold asset: ${fileName}`);
 }
@@ -3432,7 +4597,7 @@ function appFiles(preset) {
     style: () => style(preset),
     renderer: () => renderer(preset),
     index: () => indexRoute(preset),
-    slug: () => slugRoute(),
+    slug: () => slugRoute(preset),
     header: () => siteHeader(),
     article: () => article()
   };
@@ -3688,7 +4853,7 @@ var README_WORDS = {
     demoPages: "Try the demos",
     demoPagesBody: "The generated site ships content pages that exercise these features:",
     copyDemos: "Copy-paste demos",
-    copyDemosBody: "Paste any of these snippets into a Markdown file under `content/` and run `pnpm exec riebeckite dev`. Each one renders through a plugin this preset registers."
+    copyDemosBody: "Paste any of these snippets into a Markdown file under `content/` and run `npm exec riebeckite dev`. Each one renders through a plugin this preset registers."
   },
   ja: {
     included: "含まれているもの",
@@ -3712,7 +4877,7 @@ var README_WORDS = {
     demoPages: "デモを試す",
     demoPagesBody: "生成されたサイトには、各機能を体験できるコンテンツページが含まれています:",
     copyDemos: "コピーして使えるデモ",
-    copyDemosBody: "以下のスニペットを `content/` 配下の Markdown ファイルに貼り付けて `pnpm exec riebeckite dev` を実行してください。それぞれ、このプリセットが登録しているプラグインでレンダリングされます。"
+    copyDemosBody: "以下のスニペットを `content/` 配下の Markdown ファイルに貼り付けて `npm exec riebeckite dev` を実行してください。それぞれ、このプリセットが登録しているプラグインでレンダリングされます。"
   }
 };
 function readme(preset, variables) {
@@ -3745,10 +4910,10 @@ function readmeEn(preset, variables) {
   lines.push(`## ${words.commands}`, "");
   lines.push(
     "```sh",
-    "pnpm install",
-    "pnpm exec riebeckite check",
-    "pnpm exec riebeckite dev",
-    "pnpm exec riebeckite build",
+    "npm install",
+    "npm exec riebeckite check",
+    "npm exec riebeckite dev",
+    "npm exec riebeckite build",
     "```",
     ""
   );
@@ -3793,10 +4958,10 @@ function readmeJa(preset, variables) {
   lines.push(`## ${words.commands}`, "");
   lines.push(
     "```sh",
-    "pnpm install",
-    "pnpm exec riebeckite check",
-    "pnpm exec riebeckite dev",
-    "pnpm exec riebeckite build",
+    "npm install",
+    "npm exec riebeckite check",
+    "npm exec riebeckite dev",
+    "npm exec riebeckite build",
     "```",
     ""
   );
@@ -4263,7 +5428,7 @@ var ScaffoldSiteError = class extends Error {
   }
 };
 async function scaffoldRiebeckiteSite(options) {
-  const targetDirectory = path7.resolve(options.targetDirectory);
+  const targetDirectory = path9.resolve(options.targetDirectory);
   const preset = resolveScaffoldPreset(options.preset);
   validateDeploymentOptions(options);
   const files = [
@@ -4276,9 +5441,9 @@ async function scaffoldRiebeckiteSite(options) {
     options.overwrite ?? false
   );
   for (const file of files) {
-    const filePath = path7.join(targetDirectory, file.path);
-    await fs7.mkdir(path7.dirname(filePath), { recursive: true });
-    await fs7.writeFile(filePath, file.content);
+    const filePath = path9.join(targetDirectory, file.path);
+    await fs8.mkdir(path9.dirname(filePath), { recursive: true });
+    await fs8.writeFile(filePath, file.content);
   }
   return { targetDirectory, files: files.map((file) => file.path) };
 }
@@ -4314,7 +5479,7 @@ function validateDeploymentOptions(options) {
 }
 function templateVariables(options, targetDirectory) {
   const name = normalizePackageName(
-    options.name ?? path7.basename(targetDirectory)
+    options.name ?? path9.basename(targetDirectory)
   );
   return {
     name,
@@ -4327,9 +5492,9 @@ function templateVariables(options, targetDirectory) {
 async function assertTargetWritable(targetDirectory, files, overwrite) {
   let entries;
   try {
-    entries = await fs7.readdir(targetDirectory);
+    entries = await fs8.readdir(targetDirectory);
   } catch (error) {
-    if (isNotFoundError2(error)) return;
+    if (isNotFoundError3(error)) return;
     throw error;
   }
   const conflicts = entries.filter(
@@ -4347,20 +5512,31 @@ function normalizePackageName(value) {
   const normalized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-_.]+/, "").replace(/[-_.]+$/, "");
   return normalized || "riebeckite-site";
 }
-function isNotFoundError2(error) {
+function isNotFoundError3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/scaffold/next-steps.ts
-function formatScaffoldNextSteps(relativeDirectory) {
+function formatScaffoldNextSteps(relativeDirectory, options = {}) {
   const lines = ["Next steps:"];
   if (relativeDirectory !== ".") {
     lines.push(`  cd ${relativeDirectory}`);
   }
-  lines.push("  pnpm install");
-  lines.push("  pnpm exec riebeckite check");
-  lines.push("  pnpm exec riebeckite dev");
-  lines.push("  pnpm exec riebeckite build");
+  lines.push("  npm install");
+  lines.push("  npm exec riebeckite check");
+  lines.push("  npm exec riebeckite dev");
+  lines.push("  npm exec riebeckite build");
+  if (options.editFile !== void 0) {
+    lines.push("");
+    lines.push("Then edit:");
+    lines.push(`  ${options.editFile}`);
+  }
+  if (options.externalContent === true) {
+    lines.push("");
+    lines.push(
+      "Copy github/notify-site.yml to the content repository as .github/workflows/notify-site.yml."
+    );
+  }
   return lines.join("\n");
 }
 export {