@founderhq/next-blog 0.9.0

package/dist/cli/core.js

@@ -0,0 +1,1983 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { createEditableBlogTemplates } from "../registry.js";
+export function choiceFromValue(value, name, choices) {
+    if (!value)
+        return undefined;
+    if (choices.includes(value))
+        return value;
+    throw new Error(`Use ${name} with one of: ${choices.join(", ")}.`);
+}
+function normalizeInstallRoutePrefix(prefix = "/blog") {
+    const trimmed = prefix.trim().replace(/^\/+|\/+$/g, "");
+    if (!trimmed) {
+        throw new Error("Blog route prefix cannot be the site root in v1. Use /blog or another non-root prefix.");
+    }
+    return `/${trimmed}`;
+}
+function normalizeInstallAdminPath(adminPath = "/cms") {
+    const trimmed = adminPath.trim().replace(/^\/+|\/+$/g, "");
+    if (!trimmed) {
+        throw new Error("Payload admin path cannot be the site root. Use /cms or another non-root path.");
+    }
+    return `/${trimmed}`;
+}
+const OPTIONAL_MIGRATION_ENV = new Set([
+    "AZURE_STORAGE_CONNECTION_STRING",
+    "AZURE_STORAGE_CONTAINER_NAME",
+    "BLOB_READ_WRITE_TOKEN",
+    "GCS_BUCKET",
+    "GCS_PROJECT_ID",
+    "NEXT_PUBLIC_BLOG_ROUTE_PREFIX",
+    "NEXT_PUBLIC_SITE_NAME",
+    "NEXT_PUBLIC_SITE_URL",
+    "PAYLOAD_DATABASE_SCHEMA",
+    "PAYLOAD_MEDIA_PREFIX",
+    "R2_ACCOUNT_ID",
+    "R2_ACCESS_KEY_ID",
+    "R2_BUCKET",
+    "R2_SECRET_ACCESS_KEY",
+    "S3_ACCESS_KEY_ID",
+    "S3_BUCKET",
+    "S3_REGION",
+    "S3_SECRET_ACCESS_KEY",
+    "UPLOADTHING_TOKEN",
+]);
+const COMMON_DEPENDENCIES = {
+    "@founderhq/next-blog": "^0.9.0",
+    "@founderhq/payload-cms-kit": "^0.9.0",
+    "@founderhq/payload-plugin": "^0.1.0",
+    "@payloadcms/richtext-lexical": "^3.85.0",
+    graphql: "^16.8.1",
+    payload: "^3.85.0",
+    sharp: "^0.34.0",
+};
+const NEXT_DEPENDENCIES = Object.assign(Object.assign({}, COMMON_DEPENDENCIES), { "@payloadcms/next": "^3.85.0" });
+const DB_DEPENDENCIES = {
+    postgres: { "@payloadcms/db-postgres": "^3.85.0" },
+    "sqlite-local": { "@payloadcms/db-sqlite": "^3.85.0" },
+    turso: { "@payloadcms/db-sqlite": "^3.85.0" },
+};
+export const STORAGE_DEPENDENCIES = {
+    local: {},
+    s3: { "@payloadcms/storage-s3": "^3.85.0" },
+    r2: { "@payloadcms/storage-r2": "^3.85.0" },
+    "vercel-blob": { "@payloadcms/storage-vercel-blob": "^3.85.0" },
+    azure: { "@payloadcms/storage-azure": "^3.85.0" },
+    gcs: { "@payloadcms/storage-gcs": "^3.85.0" },
+    uploadthing: { "@payloadcms/storage-uploadthing": "^3.85.0" },
+    custom: {},
+};
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function isUnsetEnvValue(value) {
+    if (!(value === null || value === void 0 ? void 0 : value.trim()))
+        return true;
+    return /replace-with|your-db|user:password@host/i.test(value);
+}
+function writeJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function hasDependency(pkg, name) {
+    var _a;
+    const deps = pkg.dependencies;
+    const devDeps = pkg.devDependencies;
+    return Boolean((_a = deps === null || deps === void 0 ? void 0 : deps[name]) !== null && _a !== void 0 ? _a : devDeps === null || devDeps === void 0 ? void 0 : devDeps[name]);
+}
+function packageManagerFromPackageJson(pkg) {
+    const packageManager = typeof pkg.packageManager === "string" ? pkg.packageManager : null;
+    if (packageManager === null || packageManager === void 0 ? void 0 : packageManager.startsWith("pnpm@"))
+        return "pnpm";
+    if (packageManager === null || packageManager === void 0 ? void 0 : packageManager.startsWith("yarn@"))
+        return "yarn";
+    if (packageManager === null || packageManager === void 0 ? void 0 : packageManager.startsWith("bun@"))
+        return "bun";
+    if (packageManager === null || packageManager === void 0 ? void 0 : packageManager.startsWith("npm@"))
+        return "npm";
+    return null;
+}
+function detectPackageManager(projectRoot, pkg) {
+    var _a, _b, _c, _d;
+    return ((_d = (_c = (_b = (_a = packageManagerFromPackageJson(pkg)) !== null && _a !== void 0 ? _a : (existsSync(join(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : null)) !== null && _b !== void 0 ? _b : (existsSync(join(projectRoot, "yarn.lock")) ? "yarn" : null)) !== null && _c !== void 0 ? _c : (existsSync(join(projectRoot, "bun.lock")) ||
+        existsSync(join(projectRoot, "bun.lockb"))
+        ? "bun"
+        : null)) !== null && _d !== void 0 ? _d : "npm");
+}
+function packageManagerRunScript(projectRoot, pkg, script) {
+    const packageManager = detectPackageManager(projectRoot, pkg);
+    return `${packageManager} run ${script}`;
+}
+function packageManagerInstallCommand(projectRoot, pkg) {
+    const packageManager = detectPackageManager(projectRoot, pkg);
+    return `${packageManager} install`;
+}
+function needsPackageInstall(pkg, dependencies, devDependencies) {
+    return (Object.keys(dependencies).some((name) => !hasDependency(pkg, name)) ||
+        Object.keys(devDependencies).some((name) => !hasDependency(pkg, name)));
+}
+export function mergeMissingPackageEntries(pkg, dependencies, devDependencies) {
+    var _a, _b;
+    const next = Object.assign({}, pkg);
+    const nextDependencies = Object.assign({}, ((_a = pkg.dependencies) !== null && _a !== void 0 ? _a : {}));
+    const nextDevDependencies = Object.assign({}, ((_b = pkg.devDependencies) !== null && _b !== void 0 ? _b : {}));
+    const hasPackage = (name) => nextDependencies[name] !== undefined || nextDevDependencies[name] !== undefined;
+    for (const [name, version] of Object.entries(dependencies)) {
+        if (!hasPackage(name))
+            nextDependencies[name] = version;
+    }
+    for (const [name, version] of Object.entries(devDependencies)) {
+        if (!hasPackage(name))
+            nextDevDependencies[name] = version;
+    }
+    if (Object.keys(nextDependencies).length > 0) {
+        next.dependencies = nextDependencies;
+    }
+    else {
+        delete next.dependencies;
+    }
+    if (Object.keys(nextDevDependencies).length > 0) {
+        next.devDependencies = nextDevDependencies;
+    }
+    else {
+        delete next.devDependencies;
+    }
+    return next;
+}
+function installCommandForPlan(projectRoot, pkg, dependencies, devDependencies) {
+    return needsPackageInstall(pkg, dependencies, devDependencies)
+        ? packageManagerInstallCommand(projectRoot, pkg)
+        : null;
+}
+export function missingMigrationEnv(plan, env = process.env) {
+    return Object.keys(plan.env).filter((key) => !OPTIONAL_MIGRATION_ENV.has(key) && isUnsetEnvValue(env[key]));
+}
+export function detectAppDir(projectRoot) {
+    const srcApp = join(projectRoot, "src", "app");
+    if (existsSync(srcApp))
+        return srcApp;
+    const app = join(projectRoot, "app");
+    if (existsSync(app))
+        return app;
+    return null;
+}
+function dbImport(choice) {
+    if (choice === "postgres") {
+        return "import { postgresAdapter } from '@payloadcms/db-postgres'";
+    }
+    return "import { sqliteAdapter } from '@payloadcms/db-sqlite'";
+}
+function dbConfig(choice, schemaName) {
+    if (choice === "postgres") {
+        return `postgresAdapter({
+    pool: {
+      connectionString: process.env.PAYLOAD_DATABASE_URL || '',
+    },
+    schemaName: process.env.PAYLOAD_DATABASE_SCHEMA || '${schemaName}',
+  })`;
+    }
+    return `sqliteAdapter({
+    client: {
+      url: process.env.PAYLOAD_DATABASE_URL || 'file:./payload.db',
+      authToken: process.env.PAYLOAD_DATABASE_AUTH_TOKEN,
+    },
+  })`;
+}
+function storageImport(choice) {
+    switch (choice) {
+        case "s3":
+            return "import { s3Storage } from '@payloadcms/storage-s3'";
+        case "r2":
+            return "import { r2Storage } from '@payloadcms/storage-r2'";
+        case "vercel-blob":
+            return "import { vercelBlobStorage } from '@payloadcms/storage-vercel-blob'";
+        case "azure":
+            return "import { azureStorage } from '@payloadcms/storage-azure'";
+        case "gcs":
+            return "import { gcsStorage } from '@payloadcms/storage-gcs'";
+        case "uploadthing":
+            return "import { uploadthingStorage } from '@payloadcms/storage-uploadthing'";
+        default:
+            return null;
+    }
+}
+function storagePlugin(choice) {
+    switch (choice) {
+        case "s3":
+            return `s3Storage({
+    collections: { media: { prefix: process.env.PAYLOAD_MEDIA_PREFIX || 'blog' } },
+    bucket: process.env.S3_BUCKET || '',
+    config: {
+      region: process.env.S3_REGION,
+      credentials: {
+        accessKeyId: process.env.S3_ACCESS_KEY_ID || '',
+        secretAccessKey: process.env.S3_SECRET_ACCESS_KEY || '',
+      },
+    },
+  })`;
+        case "r2":
+            return `r2Storage({
+    collections: { media: { prefix: process.env.PAYLOAD_MEDIA_PREFIX || 'blog' } },
+    bucket: process.env.R2_BUCKET || '',
+    config: {
+      accountId: process.env.R2_ACCOUNT_ID || '',
+      accessKeyId: process.env.R2_ACCESS_KEY_ID || '',
+      secretAccessKey: process.env.R2_SECRET_ACCESS_KEY || '',
+    },
+  })`;
+        case "vercel-blob":
+            return `vercelBlobStorage({
+    collections: { media: { prefix: process.env.PAYLOAD_MEDIA_PREFIX || 'blog' } },
+    token: process.env.BLOB_READ_WRITE_TOKEN || '',
+  })`;
+        case "azure":
+            return `azureStorage({
+    collections: { media: true },
+    connectionString: process.env.AZURE_STORAGE_CONNECTION_STRING || '',
+    containerName: process.env.AZURE_STORAGE_CONTAINER_NAME || '',
+  })`;
+        case "gcs":
+            return `gcsStorage({
+    collections: { media: true },
+    bucket: process.env.GCS_BUCKET || '',
+    options: {
+      projectId: process.env.GCS_PROJECT_ID,
+    },
+  })`;
+        case "uploadthing":
+            return `uploadthingStorage({
+    collections: { media: true },
+    token: process.env.UPLOADTHING_TOKEN || '',
+  })`;
+        case "custom":
+            return null;
+        case "local":
+            return null;
+    }
+}
+function storageFile(choice) {
+    if (choice === "custom") {
+        return `export function founderHQBlogStoragePlugins() {
+  // Add your custom Payload storage adapter plugin here before production uploads.
+  return []
+}
+`;
+    }
+    const importLine = storageImport(choice);
+    const plugin = storagePlugin(choice);
+    if (!plugin) {
+        return `export function founderHQBlogStoragePlugins() {
+  return []
+}
+`;
+    }
+    return `${importLine !== null && importLine !== void 0 ? importLine : ""}
+export function founderHQBlogStoragePlugins() {
+  return [
+    ${plugin},
+  ]
+}
+`;
+}
+function payloadConfig(options) {
+    var _a, _b;
+    const schemaName = (_a = options.postgresSchema) !== null && _a !== void 0 ? _a : "payload";
+    return `import { lexicalEditor } from '@payloadcms/richtext-lexical'
+${dbImport(options.db)}
+import { buildConfig } from 'payload'
+import sharp from 'sharp'
+import {
+  createFounderHQBlogCollections,
+  createFounderHQBlogGlobals,
+  founderHQBlogRichTextFeatures,
+} from '@founderhq/payload-cms-kit'
+import { founderHQBlogStoragePlugins } from './founderhq-blog.storage'
+
+export default buildConfig({
+  admin: {
+    user: 'cms-users',
+    routes: {
+      admin: ${JSON.stringify((_b = options.adminPath) !== null && _b !== void 0 ? _b : "/cms")},
+    },
+  },
+  collections: [
+    {
+      slug: 'cms-users',
+      auth: true,
+      fields: [],
+    },
+    ...createFounderHQBlogCollections(),
+  ],
+  globals: createFounderHQBlogGlobals(),
+  editor: lexicalEditor({
+    features: founderHQBlogRichTextFeatures(),
+  }),
+  db: ${dbConfig(options.db, schemaName)},
+  plugins: founderHQBlogStoragePlugins(),
+  secret: process.env.PAYLOAD_SECRET || '',
+  sharp,
+})
+`;
+}
+function payloadRestRoute() {
+    return `import config from '@payload-config'
+import {
+  REST_DELETE,
+  REST_GET,
+  REST_OPTIONS,
+  REST_PATCH,
+  REST_POST,
+  REST_PUT,
+} from '@payloadcms/next/routes'
+
+export const GET = REST_GET(config)
+export const POST = REST_POST(config)
+export const DELETE = REST_DELETE(config)
+export const PATCH = REST_PATCH(config)
+export const PUT = REST_PUT(config)
+export const OPTIONS = REST_OPTIONS(config)
+`;
+}
+function payloadImportMap() {
+    return `/** @type {import('payload').ImportMap} */
+export const importMap = {}
+`;
+}
+function payloadAdminPage() {
+    return `import type { Metadata } from 'next'
+import config from '@payload-config'
+import { RootPage, generatePageMetadata } from '@payloadcms/next/views'
+import { importMap } from '../importMap.js'
+
+type Args = {
+  params: Promise<{ segments: string[] }>
+  searchParams: Promise<{ [key: string]: string | string[] }>
+}
+
+export const generateMetadata = ({
+  params,
+  searchParams,
+}: Args): Promise<Metadata> =>
+  generatePageMetadata({ config, params, searchParams })
+
+const Page = ({ params, searchParams }: Args) =>
+  RootPage({ config, params, searchParams, importMap })
+
+export default Page
+`;
+}
+function payloadLayout(adminSegment) {
+    return `import config from '@payload-config'
+import '@payloadcms/next/css'
+import type { ServerFunctionClient } from 'payload'
+import { handleServerFunctions, RootLayout } from '@payloadcms/next/layouts'
+import React from 'react'
+import { importMap } from './${adminSegment}/importMap.js'
+import './custom.css'
+
+type Args = {
+  children: React.ReactNode
+}
+
+const serverFunction: ServerFunctionClient = async function (args) {
+  'use server'
+  return handleServerFunctions({
+    ...args,
+    config,
+    importMap,
+  })
+}
+
+const Layout = ({ children }: Args) => (
+  <RootLayout config={config} importMap={importMap} serverFunction={serverFunction}>
+    {children}
+  </RootLayout>
+)
+
+export default Layout
+`;
+}
+function patchNextConfig(content) {
+    if (content.includes("withPayload("))
+        return content;
+    if (!content.includes("export default"))
+        return null;
+    const importLine = "import { withPayload } from '@payloadcms/next/withPayload'\n";
+    const withImport = content.includes("@payloadcms/next/withPayload")
+        ? content
+        : `${importLine}${content}`;
+    return `${withImport.replace(/export\s+default\s+/, "const founderHQNextConfig = ")}
+
+export default withPayload(founderHQNextConfig)
+`;
+}
+function nextConfigChange(projectRoot) {
+    const candidates = ["next.config.ts", "next.config.mjs", "next.config.js"];
+    for (const candidate of candidates) {
+        const path = join(projectRoot, candidate);
+        if (!existsSync(path))
+            continue;
+        const content = readFileSync(path, "utf8");
+        const patched = patchNextConfig(content);
+        if (!patched)
+            return null;
+        return { kind: "update", path: candidate, content: patched };
+    }
+    const unsupported = ["next.config.cjs", "next.config.mts", "next.config.cts"].find((candidate) => existsSync(join(projectRoot, candidate)));
+    if (unsupported) {
+        throw new Error(`Existing ${unsupported} was found. The v1 installer only patches ESM export-default Next configs. Wrap your config with withPayload manually or convert it before running the installer.`);
+    }
+    return {
+        kind: "create",
+        path: "next.config.mjs",
+        content: `import { withPayload } from '@payloadcms/next/withPayload'
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {}
+
+export default withPayload(nextConfig)
+`,
+    };
+}
+function tsconfigChange(projectRoot) {
+    const path = join(projectRoot, "tsconfig.json");
+    const existing = readJson(path);
+    const next = existing !== null && existing !== void 0 ? existing : { compilerOptions: {} };
+    const compilerOptions = next.compilerOptions && typeof next.compilerOptions === "object"
+        ? next.compilerOptions
+        : {};
+    const paths = compilerOptions.paths && typeof compilerOptions.paths === "object"
+        ? compilerOptions.paths
+        : {};
+    paths["@payload-config"] = ["./payload.config.ts"];
+    compilerOptions.paths = paths;
+    next.compilerOptions = compilerOptions;
+    return {
+        kind: existing ? "update" : "create",
+        path: "tsconfig.json",
+        content: writeJson(next),
+    };
+}
+function existingPayloadConfig(projectRoot) {
+    return [
+        "payload.config.ts",
+        "payload.config.mts",
+        "payload.config.js",
+        "payload.config.mjs",
+        "payload.config.cjs",
+    ].find((candidate) => existsSync(join(projectRoot, candidate)));
+}
+function blogDataFile() {
+    return `import {
+  filterBlogArticlesByAuthor,
+  filterBlogArticlesByCategory,
+  filterBlogArticlesByTag,
+  fetchAllPayloadBlogPosts,
+  fetchPayloadBlogAuthorBySlug,
+  fetchPayloadBlogAuthors,
+  fetchPayloadBlogCategories,
+  fetchPayloadBlogCategoryBySlug,
+  fetchPayloadBlogPostBySlug,
+  fetchPayloadBlogPostByPreviousSlug,
+  fetchPayloadBlogPosts,
+  fetchPayloadBlogRedirect,
+  fetchPayloadBlogTagBySlug,
+  fetchPayloadBlogTags,
+  paginateBlogArticles,
+} from '@founderhq/next-blog/server'
+
+export const founderHQBlogSite = {
+  siteName: process.env.NEXT_PUBLIC_SITE_NAME || 'Blog',
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'http://localhost:3000',
+  routePrefix: process.env.NEXT_PUBLIC_BLOG_ROUTE_PREFIX || '/blog',
+}
+
+const payloadBaseUrl =
+  process.env.PAYLOAD_PUBLIC_SERVER_URL ||
+  process.env.NEXT_PUBLIC_SITE_URL ||
+  'http://localhost:3000'
+
+export const founderHQBlogPageSize = 12
+
+export function listBlogPosts(page = 1) {
+  return fetchPayloadBlogPosts({
+    baseUrl: payloadBaseUrl,
+    limit: founderHQBlogPageSize,
+    page,
+  })
+}
+
+export function listAllBlogPosts() {
+  return fetchAllPayloadBlogPosts({ baseUrl: payloadBaseUrl, limit: 100 })
+}
+
+export function listBlogAuthors() {
+  return fetchPayloadBlogAuthors({ baseUrl: payloadBaseUrl, limit: 100 })
+}
+
+export function listBlogCategories() {
+  return fetchPayloadBlogCategories({ baseUrl: payloadBaseUrl, limit: 100 })
+}
+
+export function listBlogTags() {
+  return fetchPayloadBlogTags({ baseUrl: payloadBaseUrl, limit: 100 })
+}
+
+export function getBlogPostBySlug(slug: string) {
+  return fetchPayloadBlogPostBySlug({ baseUrl: payloadBaseUrl, slug })
+}
+
+export function getBlogAuthorBySlug(slug: string) {
+  return fetchPayloadBlogAuthorBySlug({ baseUrl: payloadBaseUrl, slug })
+}
+
+export function getBlogCategoryBySlug(slug: string) {
+  return fetchPayloadBlogCategoryBySlug({ baseUrl: payloadBaseUrl, slug })
+}
+
+export function getBlogTagBySlug(slug: string) {
+  return fetchPayloadBlogTagBySlug({ baseUrl: payloadBaseUrl, slug })
+}
+
+export async function listBlogPostsByAuthor(slug: string, page = 1) {
+  const author = await getBlogAuthorBySlug(slug)
+  if (!author) return null
+  const posts = await listAllBlogPosts()
+  return {
+    author,
+    posts: paginateBlogArticles(
+      filterBlogArticlesByAuthor(posts.docs, author),
+      page,
+      founderHQBlogPageSize,
+    ),
+  }
+}
+
+export async function listBlogPostsByCategory(slug: string, page = 1) {
+  const category = await getBlogCategoryBySlug(slug)
+  if (!category) return null
+  const posts = await listAllBlogPosts()
+  return {
+    category,
+    posts: paginateBlogArticles(
+      filterBlogArticlesByCategory(posts.docs, category),
+      page,
+      founderHQBlogPageSize,
+    ),
+  }
+}
+
+export async function listBlogPostsByTag(slug: string, page = 1) {
+  const tag = await getBlogTagBySlug(slug)
+  if (!tag) return null
+  const posts = await listAllBlogPosts()
+  return {
+    tag,
+    posts: paginateBlogArticles(
+      filterBlogArticlesByTag(posts.docs, tag),
+      page,
+      founderHQBlogPageSize,
+    ),
+  }
+}
+
+export function getBlogPostByPreviousSlug(slug: string) {
+  return fetchPayloadBlogPostByPreviousSlug({ baseUrl: payloadBaseUrl, slug })
+}
+
+export function getBlogRedirect(path: string) {
+  return fetchPayloadBlogRedirect({ baseUrl: payloadBaseUrl, path })
+}
+`;
+}
+function importPath(fromFile, toFile) {
+    const raw = relative(dirname(fromFile), toFile)
+        .replaceAll(sep, "/")
+        .replace(/\.(ts|tsx)$/, "");
+    return raw.startsWith(".") ? raw : `./${raw}`;
+}
+function blogIndexPage(blogDataImport, blogComponentsImport, blogStylesImport) {
+    return `import {
+  absoluteUrl,
+  buildBlogPagination,
+  normalizeRoutePrefix,
+} from '@founderhq/next-blog/server'
+import { BlogIndex } from '${blogComponentsImport}'
+import { founderHQBlogSite, listBlogPosts } from '${blogDataImport}'
+import '${blogStylesImport}'
+
+export function generateMetadata() {
+  const canonical = absoluteUrl(
+    founderHQBlogSite.siteUrl,
+    normalizeRoutePrefix(founderHQBlogSite.routePrefix),
+  )
+  const title = \`\${founderHQBlogSite.siteName} Blog\`
+  const description = \`\${founderHQBlogSite.siteName} articles\`
+
+  return {
+    title,
+    description,
+    alternates: { canonical },
+    openGraph: {
+      type: 'website',
+      url: canonical,
+      siteName: founderHQBlogSite.siteName,
+      title,
+      description,
+    },
+    twitter: {
+      card: 'summary_large_image',
+      title,
+      description,
+    },
+  }
+}
+
+export default async function BlogPage() {
+  const posts = await listBlogPosts()
+  return (
+    <BlogIndex
+      articles={posts.docs}
+      site={founderHQBlogSite}
+      pagination={buildBlogPagination({
+        site: founderHQBlogSite,
+        page: posts.page ?? 1,
+        totalPages: posts.totalPages ?? 1,
+        totalDocs: posts.totalDocs,
+      })}
+    />
+  )
+}
+`;
+}
+function blogPaginatedIndexPage(blogDataImport, blogComponentsImport, blogStylesImport) {
+    return `import {
+  absoluteUrl,
+  buildBlogPagination,
+  normalizeRoutePrefix,
+} from '@founderhq/next-blog/server'
+import { BlogIndex } from '${blogComponentsImport}'
+import { founderHQBlogSite, listBlogPosts } from '${blogDataImport}'
+import { notFound, permanentRedirect } from 'next/navigation'
+import '${blogStylesImport}'
+
+function pageNumber(value: string) {
+  const page = Number(value)
+  return Number.isInteger(page) && page > 0 ? page : null
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ page: string }>
+}) {
+  const { page: rawPage } = await params
+  const page = pageNumber(rawPage)
+  if (!page) return {}
+  const canonical = absoluteUrl(
+    founderHQBlogSite.siteUrl,
+    \`\${normalizeRoutePrefix(founderHQBlogSite.routePrefix)}/page/\${page}\`,
+  )
+  const title = \`\${founderHQBlogSite.siteName} Blog - Page \${page}\`
+  const description = \`\${founderHQBlogSite.siteName} articles, page \${page}\`
+
+  return {
+    title,
+    description,
+    alternates: { canonical },
+    openGraph: {
+      type: 'website',
+      url: canonical,
+      siteName: founderHQBlogSite.siteName,
+      title,
+      description,
+    },
+    twitter: {
+      card: 'summary_large_image',
+      title,
+      description,
+    },
+  }
+}
+
+export default async function BlogPaginatedPage({
+  params,
+}: {
+  params: Promise<{ page: string }>
+}) {
+  const { page: rawPage } = await params
+  const page = pageNumber(rawPage)
+  if (!page) notFound()
+  if (page === 1) permanentRedirect(normalizeRoutePrefix(founderHQBlogSite.routePrefix) || '/')
+  const posts = await listBlogPosts(page)
+  if (page > (posts.totalPages ?? 1)) notFound()
+
+  return (
+    <BlogIndex
+      articles={posts.docs}
+      site={founderHQBlogSite}
+      title={\`\${founderHQBlogSite.siteName} Blog - Page \${page}\`}
+      pagination={buildBlogPagination({
+        site: founderHQBlogSite,
+        page,
+        totalPages: posts.totalPages ?? 1,
+        totalDocs: posts.totalDocs,
+      })}
+    />
+  )
+}
+`;
+}
+function blogArticlePage(blogDataImport, blogComponentsImport, blogStylesImport) {
+    return `import { articlePath, normalizeRoutePrefix } from '@founderhq/next-blog'
+import { BlogArticleLayout } from '${blogComponentsImport}'
+import {
+  buildArticleJsonLd,
+  buildArticleMetadata,
+} from '@founderhq/next-blog/server'
+import { notFound, permanentRedirect, redirect } from 'next/navigation'
+import {
+  founderHQBlogSite,
+  getBlogPostByPreviousSlug,
+  getBlogPostBySlug,
+  getBlogRedirect,
+} from '${blogDataImport}'
+import '${blogStylesImport}'
+
+async function redirectMissingPost(slug: string) {
+  const legacyPath = \`\${normalizeRoutePrefix(founderHQBlogSite.routePrefix)}/\${slug}\`
+  const manualRedirect = await getBlogRedirect(legacyPath)
+  if (manualRedirect?.to) {
+    const statusCode = Number(manualRedirect.statusCode ?? 301)
+    if (statusCode === 301 || statusCode === 308) {
+      permanentRedirect(String(manualRedirect.to))
+    }
+    redirect(String(manualRedirect.to))
+  }
+
+  const movedPost = await getBlogPostByPreviousSlug(slug)
+  if (movedPost) {
+    permanentRedirect(articlePath(movedPost, founderHQBlogSite))
+  }
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ slug: string }>
+}) {
+  const { slug } = await params
+  const post = await getBlogPostBySlug(slug)
+  if (!post) return {}
+  const metadata = buildArticleMetadata(post, founderHQBlogSite)
+  return {
+    title: metadata.title,
+    description: metadata.description,
+    alternates: { canonical: metadata.canonical },
+    robots: metadata.robots,
+    openGraph: metadata.openGraph,
+    twitter: metadata.twitter,
+  }
+}
+
+export default async function BlogArticlePage({
+  params,
+}: {
+  params: Promise<{ slug: string }>
+}) {
+  const { slug } = await params
+  const post = await getBlogPostBySlug(slug)
+  if (!post) {
+    await redirectMissingPost(slug)
+    notFound()
+  }
+  return (
+    <>
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{
+          __html: JSON.stringify(buildArticleJsonLd(post, founderHQBlogSite)).replace(
+            /</g,
+            '\\\\u003c',
+          ),
+        }}
+      />
+      <BlogArticleLayout article={post} site={founderHQBlogSite} />
+    </>
+  )
+}
+`;
+}
+function blogSearchPage(blogDataImport, blogComponentsImport, blogStylesImport) {
+    return `import { absoluteUrl, normalizeRoutePrefix } from '@founderhq/next-blog/server'
+import { BlogIndex } from '${blogComponentsImport}'
+import { searchBlogArticles } from '@founderhq/next-blog/server'
+import { founderHQBlogSite, listAllBlogPosts } from '${blogDataImport}'
+import '${blogStylesImport}'
+
+export function generateMetadata() {
+  const canonical = absoluteUrl(
+    founderHQBlogSite.siteUrl,
+    \`\${normalizeRoutePrefix(founderHQBlogSite.routePrefix)}/search\`,
+  )
+
+  return {
+    title: \`Search \${founderHQBlogSite.siteName} Blog\`,
+    alternates: { canonical },
+    robots: {
+      index: false,
+      follow: true,
+      googleBot: {
+        index: false,
+        follow: true,
+      },
+    },
+  }
+}
+
+export default async function BlogSearchPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ q?: string | string[] }>
+}) {
+  const { q: rawQuery = '' } = await searchParams
+  const q = Array.isArray(rawQuery) ? rawQuery[0] ?? '' : rawQuery
+  const posts = await listAllBlogPosts()
+  const results = q ? searchBlogArticles(posts.docs, q) : []
+  return <BlogIndex articles={results} site={founderHQBlogSite} searchInitialQuery={q} />
+}
+`;
+}
+function blogDirectoryPage(type, blogDataImport, blogComponentsImport, blogStylesImport) {
+    const listFn = type === "authors"
+        ? "listBlogAuthors"
+        : type === "categories"
+            ? "listBlogCategories"
+            : "listBlogTags";
+    const pathFn = type === "authors" ? "authorPath" : type === "categories" ? "categoryPath" : "tagPath";
+    const title = type === "authors" ? "Authors" : type === "categories" ? "Categories" : "Tags";
+    const itemTitle = type === "authors" ? "item.name" : "item.title";
+    const itemDescription = type === "authors" ? "item.bio ?? item.title" : "item.description";
+    const itemImage = type === "authors" ? "image: item.avatar," : "";
+    return `import { absoluteUrl, normalizeRoutePrefix, ${pathFn} } from '@founderhq/next-blog/server'
+import { BlogDirectory } from '${blogComponentsImport}'
+import { founderHQBlogSite, ${listFn} } from '${blogDataImport}'
+import '${blogStylesImport}'
+
+export function generateMetadata() {
+  const canonical = absoluteUrl(
+    founderHQBlogSite.siteUrl,
+    \`\${normalizeRoutePrefix(founderHQBlogSite.routePrefix)}/${type}\`,
+  )
+  const title = \`\${founderHQBlogSite.siteName} Blog ${title}\`
+  return {
+    title,
+    alternates: { canonical },
+    openGraph: {
+      type: 'website',
+      url: canonical,
+      siteName: founderHQBlogSite.siteName,
+      title,
+    },
+  }
+}
+
+export default async function BlogDirectoryPage() {
+  const items = await ${listFn}()
+  return (
+    <BlogDirectory
+      title="${title}"
+      items={items.docs.map((item) => ({
+        title: ${itemTitle},
+        href: ${pathFn}(item, founderHQBlogSite),
+        description: ${itemDescription},
+        ${itemImage}
+      }))}
+    />
+  )
+}
+`;
+}
+function blogArchivePage(type, paginated, blogDataImport, blogComponentsImport, blogStylesImport) {
+    const listFn = type === "author"
+        ? "listBlogPostsByAuthor"
+        : type === "category"
+            ? "listBlogPostsByCategory"
+            : "listBlogPostsByTag";
+    const pathFn = type === "author" ? "authorPath" : type === "category" ? "categoryPath" : "tagPath";
+    const entity = type;
+    const titleExpr = type === "author"
+        ? "archive.author.name"
+        : type === "category"
+            ? "archive.category.title"
+            : "archive.tag.title";
+    const descriptionExpr = type === "author"
+        ? "archive.author.bio"
+        : type === "category"
+            ? "archive.category.description"
+            : "archive.tag.description";
+    const entityExpr = type === "author"
+        ? "archive.author"
+        : type === "category"
+            ? "archive.category"
+            : "archive.tag";
+    const pageParam = paginated ? ", page" : "";
+    const routeParams = paginated
+        ? "params: Promise<{ slug: string; page: string }>"
+        : "params: Promise<{ slug: string }>";
+    const pageParser = paginated
+        ? `
+function pageNumber(value: string) {
+  const page = Number(value)
+  return Number.isInteger(page) && page > 0 ? page : null
+}
+`
+        : "";
+    const metadataPage = paginated
+        ? `
+  const page = pageNumber(rawPage)
+  if (!page) return {}
+`
+        : "";
+    const pageRead = paginated
+        ? "  const { slug, page: rawPage } = await params"
+        : "  const { slug } = await params";
+    const pageRuntime = paginated
+        ? `
+  const page = pageNumber(rawPage)
+  if (!page) notFound()
+`
+        : "  const page = 1\n";
+    const redirectPageOne = paginated
+        ? `
+  if (page === 1) permanentRedirect(${pathFn}(${entityExpr}, founderHQBlogSite))
+`
+        : "";
+    const pageTitle = paginated
+        ? `\`\${${titleExpr}} articles - Page \${page}\``
+        : `\`\${${titleExpr}} articles\``;
+    return `import {
+  absoluteUrl,
+  buildBlogPagination,
+  ${pathFn},
+} from '@founderhq/next-blog/server'
+import { BlogIndex } from '${blogComponentsImport}'
+import { founderHQBlogSite, ${listFn} } from '${blogDataImport}'
+import { notFound${paginated ? ", permanentRedirect" : ""} } from 'next/navigation'
+import '${blogStylesImport}'
+${pageParser}
+export async function generateMetadata({
+  params,
+}: {
+  ${routeParams}
+}) {
+${pageRead}
+${metadataPage}  const archive = await ${listFn}(slug${pageParam})
+  if (!archive) return {}
+  const canonical = absoluteUrl(
+    founderHQBlogSite.siteUrl,
+    ${paginated ? `\`\${${pathFn}(${entityExpr}, founderHQBlogSite)}/page/\${page}\`` : `${pathFn}(${entityExpr}, founderHQBlogSite)`},
+  )
+  const title = ${pageTitle}
+  const description = ${descriptionExpr} ?? title
+
+  return {
+    title,
+    description,
+    alternates: { canonical },
+    openGraph: {
+      type: 'website',
+      url: canonical,
+      siteName: founderHQBlogSite.siteName,
+      title,
+      description,
+    },
+  }
+}
+
+export default async function BlogArchivePage({
+  params,
+}: {
+  ${routeParams}
+}) {
+${pageRead}
+${pageRuntime}  const archive = await ${listFn}(slug${pageParam})
+  if (!archive) notFound()
+${redirectPageOne}  if (page > (archive.posts.totalPages ?? 1)) notFound()
+  const basePath = ${pathFn}(${entityExpr}, founderHQBlogSite)
+
+  return (
+    <BlogIndex
+      articles={archive.posts.docs}
+      site={founderHQBlogSite}
+      title={${pageTitle}}
+      description={${descriptionExpr}}
+      pagination={buildBlogPagination({
+        site: founderHQBlogSite,
+        page,
+        totalPages: archive.posts.totalPages ?? 1,
+        totalDocs: archive.posts.totalDocs,
+        basePath,
+      })}
+    />
+  )
+}
+`;
+}
+function rssRoute(blogDataImport) {
+    return `import { buildRssXml } from '@founderhq/next-blog/server'
+import { founderHQBlogSite, listAllBlogPosts } from '${blogDataImport}'
+
+export async function GET() {
+  const posts = await listAllBlogPosts()
+  return new Response(
+    buildRssXml({ site: founderHQBlogSite, articles: posts.docs }),
+    {
+      headers: {
+        'content-type': 'application/rss+xml; charset=utf-8',
+      },
+    },
+  )
+}
+`;
+}
+function blogPostsSitemapRoute(blogDataImport) {
+    return `import {
+  buildBlogIndexSitemapEntries,
+  buildBlogSitemapEntries,
+  buildSitemapUrlsetXml,
+} from '@founderhq/next-blog/server'
+import {
+  founderHQBlogPageSize,
+  founderHQBlogSite,
+  listAllBlogPosts,
+} from '${blogDataImport}'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const posts = await listAllBlogPosts()
+  const totalPages = Math.max(
+    1,
+    Math.ceil((posts.totalDocs ?? posts.docs.length) / founderHQBlogPageSize),
+  )
+  const entries = [
+    ...buildBlogIndexSitemapEntries(founderHQBlogSite, totalPages),
+    ...buildBlogSitemapEntries(founderHQBlogSite, posts.docs),
+  ]
+
+  return new Response(buildSitemapUrlsetXml(entries), {
+    headers: {
+      'content-type': 'application/xml; charset=utf-8',
+      'cache-control': 's-maxage=3600, stale-while-revalidate=86400',
+    },
+  })
+}
+`;
+}
+function blogTaxonomySitemapRoute(type, blogDataImport) {
+    const listFn = type === "authors"
+        ? "listBlogAuthors"
+        : type === "categories"
+            ? "listBlogCategories"
+            : "listBlogTags";
+    const buildFn = type === "authors"
+        ? "buildBlogAuthorSitemapEntries"
+        : type === "categories"
+            ? "buildBlogCategorySitemapEntries"
+            : "buildBlogTagSitemapEntries";
+    const filterFn = type === "authors"
+        ? "filterBlogArticlesByAuthor"
+        : type === "categories"
+            ? "filterBlogArticlesByCategory"
+            : "filterBlogArticlesByTag";
+    const pathFn = type === "authors" ? "authorPath" : type === "categories" ? "categoryPath" : "tagPath";
+    const directoryPath = `\`\${normalizeRoutePrefix(founderHQBlogSite.routePrefix)}/${type}\``;
+    return `import {
+  absoluteUrl,
+  ${buildFn},
+  buildBlogPaginatedSitemapEntries,
+  buildSitemapUrlsetXml,
+  ${filterFn},
+  normalizeRoutePrefix,
+  ${pathFn},
+} from '@founderhq/next-blog/server'
+import {
+  founderHQBlogPageSize,
+  founderHQBlogSite,
+  listAllBlogPosts,
+  ${listFn},
+} from '${blogDataImport}'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const [items, posts] = await Promise.all([${listFn}(), listAllBlogPosts()])
+  const entries = [
+    { url: absoluteUrl(founderHQBlogSite.siteUrl, ${directoryPath}) },
+    ...${buildFn}(founderHQBlogSite, items.docs),
+    ...items.docs.flatMap((item) => {
+      if (!item.slug) return []
+      return buildBlogPaginatedSitemapEntries(
+        founderHQBlogSite,
+        ${pathFn}(item, founderHQBlogSite),
+        ${filterFn}(posts.docs, item).length,
+        founderHQBlogPageSize,
+      ).slice(1)
+    }),
+  ]
+
+  return new Response(buildSitemapUrlsetXml(entries), {
+    headers: {
+      'content-type': 'application/xml; charset=utf-8',
+      'cache-control': 's-maxage=3600, stale-while-revalidate=86400',
+    },
+  })
+}
+`;
+}
+function rootSitemapIndexRoute(blogDataImport) {
+    return `import {
+  absoluteUrl,
+  buildSitemapIndexXml,
+} from '@founderhq/next-blog/server'
+import { founderHQBlogSite } from '${blogDataImport}'
+
+export async function GET() {
+  return new Response(
+    buildSitemapIndexXml([
+      {
+        url: absoluteUrl(founderHQBlogSite.siteUrl, '/sitemaps/blog-posts.xml'),
+      },
+      {
+        url: absoluteUrl(founderHQBlogSite.siteUrl, '/sitemaps/blog-authors.xml'),
+      },
+      {
+        url: absoluteUrl(founderHQBlogSite.siteUrl, '/sitemaps/blog-categories.xml'),
+      },
+      {
+        url: absoluteUrl(founderHQBlogSite.siteUrl, '/sitemaps/blog-tags.xml'),
+      },
+    ]),
+    {
+      headers: {
+        'content-type': 'application/xml; charset=utf-8',
+        'cache-control': 's-maxage=3600, stale-while-revalidate=86400',
+      },
+    },
+  )
+}
+`;
+}
+function robotsMetadataRoute(blogDataImport) {
+    return `import { buildBlogRobots } from '@founderhq/next-blog/server'
+import { founderHQBlogSite } from '${blogDataImport}'
+
+export default function robots() {
+  return buildBlogRobots(founderHQBlogSite)
+}
+`;
+}
+function absoluteFromSite(siteUrl, path) {
+    return new URL(path, `${siteUrl.replace(/\/$/, "")}/`).toString();
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function patchStaticRobots(content, sitemapUrl) {
+    if (/^\s*sitemap\s*:/im.test(content))
+        return content;
+    return `${content.trimEnd()}\nSitemap: ${sitemapUrl}\n`;
+}
+function patchMetadataRobots(content, sitemapUrl) {
+    if (content.includes("sitemap"))
+        return content;
+    const functionMatch = /export\s+default\s+(?:async\s+)?function\s+robots\s*\(/.exec(content);
+    if (!functionMatch)
+        return null;
+    const openBrace = content.indexOf("{", functionMatch.index);
+    if (openBrace === -1)
+        return null;
+    const closeBrace = findMatching(content, openBrace, "{", "}");
+    if (closeBrace === -1)
+        return null;
+    const body = content.slice(openBrace + 1, closeBrace);
+    const returnIndexInBody = body.indexOf("return");
+    if (returnIndexInBody === -1)
+        return null;
+    const absoluteReturnIndex = openBrace + 1 + returnIndexInBody;
+    const objectStart = content.indexOf("{", absoluteReturnIndex);
+    if (objectStart === -1 || objectStart > closeBrace)
+        return null;
+    const objectEnd = findMatching(content, objectStart, "{", "}");
+    if (objectEnd === -1 || objectEnd > closeBrace)
+        return null;
+    if (content.slice(objectEnd + 1, closeBrace).replace(/[);]|\s/g, "")) {
+        return null;
+    }
+    const objectBody = content.slice(objectStart + 1, objectEnd);
+    const needsComma = objectBody.trim().length > 0 && !objectBody.trimEnd().endsWith(",");
+    return `${content.slice(0, objectEnd)}${needsComma ? "," : ""}\n    sitemap: ${JSON.stringify(sitemapUrl)},${content.slice(objectEnd)}`;
+}
+function patchStaticSitemapIndex(content, urls) {
+    if (!/<sitemapindex\b/i.test(content))
+        return null;
+    const additions = urls
+        .filter((url) => !content.includes(url))
+        .map((url) => `  <sitemap><loc>${escapeXml(url)}</loc></sitemap>`);
+    if (additions.length === 0)
+        return content;
+    const patched = content.replace(/<\/sitemapindex>\s*$/i, `${additions.join("\n")}\n</sitemapindex>\n`);
+    return patched === content ? null : patched;
+}
+function findMatching(source, openIndex, open, close) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (lineComment) {
+            if (char === "\n")
+                lineComment = false;
+            continue;
+        }
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === open)
+            depth += 1;
+        if (char === close) {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function patchMetadataSitemap(content, blogDataImport) {
+    if (content.includes("founderHQBlogSitemapMetadata"))
+        return content;
+    const functionMatch = /export\s+default\s+(?:async\s+)?function\s+sitemap\s*\(/.exec(content);
+    if (!functionMatch)
+        return null;
+    const openBrace = content.indexOf("{", functionMatch.index);
+    if (openBrace === -1)
+        return null;
+    const closeBrace = findMatching(content, openBrace, "{", "}");
+    if (closeBrace === -1)
+        return null;
+    const body = content.slice(openBrace + 1, closeBrace);
+    const returnIndexInBody = body.indexOf("return");
+    if (returnIndexInBody === -1)
+        return null;
+    if (body.slice(0, returnIndexInBody).trim())
+        return null;
+    const absoluteReturnIndex = openBrace + 1 + returnIndexInBody;
+    const arrayStart = content.indexOf("[", absoluteReturnIndex);
+    if (arrayStart === -1 || arrayStart > closeBrace)
+        return null;
+    const arrayEnd = findMatching(content, arrayStart, "[", "]");
+    if (arrayEnd === -1 || arrayEnd > closeBrace)
+        return null;
+    if (content.slice(arrayEnd + 1, closeBrace).replace(/;|\s/g, ""))
+        return null;
+    const existingArray = content.slice(arrayStart, arrayEnd + 1);
+    const beforeFunction = content.slice(0, functionMatch.index).trimEnd();
+    const afterFunction = content.slice(closeBrace + 1).trimStart();
+    const metadataImport = content.includes("MetadataRoute")
+        ? ""
+        : "import type { MetadataRoute } from 'next'\n";
+    const blogImports = `import {
+  authorPath,
+  buildBlogAuthorSitemapEntries,
+  buildBlogCategorySitemapEntries,
+  buildBlogDirectorySitemapEntries,
+  buildBlogIndexSitemapEntries,
+  buildBlogPaginatedSitemapEntries,
+  buildBlogSitemapEntries,
+  buildBlogTagSitemapEntries,
+  categoryPath,
+  filterBlogArticlesByAuthor,
+  filterBlogArticlesByCategory,
+  filterBlogArticlesByTag,
+  tagPath,
+  type BlogSitemapEntry,
+} from '@founderhq/next-blog/server'
+import {
+  founderHQBlogPageSize,
+  founderHQBlogSite,
+  listAllBlogPosts,
+  listBlogAuthors,
+  listBlogCategories,
+  listBlogTags,
+} from '${blogDataImport}'
+`;
+    const helper = `function founderHQBlogSitemapMetadata(
+  entries: BlogSitemapEntry[],
+): MetadataRoute.Sitemap {
+  return entries.map((entry) => ({
+    url: entry.url,
+    ...(entry.lastModified ? { lastModified: new Date(entry.lastModified) } : {}),
+  }))
+}
+`;
+    const nextFunction = `export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  const founderHQExistingSitemap: MetadataRoute.Sitemap = ${existingArray}
+  const [
+    founderHQBlogPosts,
+    founderHQBlogAuthors,
+    founderHQBlogCategories,
+    founderHQBlogTags,
+  ] = await Promise.all([
+    listAllBlogPosts(),
+    listBlogAuthors(),
+    listBlogCategories(),
+    listBlogTags(),
+  ])
+  const founderHQBlogIndexPages = Math.max(
+    1,
+    Math.ceil(
+      (founderHQBlogPosts.totalDocs ?? founderHQBlogPosts.docs.length) /
+        founderHQBlogPageSize,
+    ),
+  )
+
+  return [
+    ...founderHQExistingSitemap,
+    ...founderHQBlogSitemapMetadata(
+      buildBlogIndexSitemapEntries(founderHQBlogSite, founderHQBlogIndexPages),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      buildBlogDirectorySitemapEntries(founderHQBlogSite),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      buildBlogSitemapEntries(founderHQBlogSite, founderHQBlogPosts.docs),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      buildBlogAuthorSitemapEntries(founderHQBlogSite, founderHQBlogAuthors.docs),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      founderHQBlogAuthors.docs.flatMap((author) => {
+        if (!author.slug) return []
+        return buildBlogPaginatedSitemapEntries(
+          founderHQBlogSite,
+          authorPath(author, founderHQBlogSite),
+          filterBlogArticlesByAuthor(founderHQBlogPosts.docs, author).length,
+          founderHQBlogPageSize,
+        ).slice(1)
+      }),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      buildBlogCategorySitemapEntries(
+        founderHQBlogSite,
+        founderHQBlogCategories.docs,
+      ),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      founderHQBlogCategories.docs.flatMap((category) =>
+        buildBlogPaginatedSitemapEntries(
+          founderHQBlogSite,
+          categoryPath(category, founderHQBlogSite),
+          filterBlogArticlesByCategory(founderHQBlogPosts.docs, category).length,
+          founderHQBlogPageSize,
+        ).slice(1),
+      ),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      buildBlogTagSitemapEntries(founderHQBlogSite, founderHQBlogTags.docs),
+    ),
+    ...founderHQBlogSitemapMetadata(
+      founderHQBlogTags.docs.flatMap((tag) =>
+        buildBlogPaginatedSitemapEntries(
+          founderHQBlogSite,
+          tagPath(tag, founderHQBlogSite),
+          filterBlogArticlesByTag(founderHQBlogPosts.docs, tag).length,
+          founderHQBlogPageSize,
+        ).slice(1),
+      ),
+    ),
+  ]
+}
+`;
+    return [
+        metadataImport,
+        blogImports,
+        beforeFunction,
+        helper,
+        nextFunction,
+        afterFunction,
+    ]
+        .filter((part) => part.trim().length > 0)
+        .join("\n\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd()
+        .concat("\n");
+}
+function envEntries(options) {
+    var _a, _b, _c;
+    const routePrefix = normalizeInstallRoutePrefix((_a = options.routePrefix) !== null && _a !== void 0 ? _a : "/blog");
+    const base = {
+        PAYLOAD_SECRET: "replace-with-a-long-random-secret",
+        PAYLOAD_DATABASE_URL: options.db === "postgres"
+            ? "postgres://user:password@host:5432/database"
+            : options.db === "turso"
+                ? "libsql://your-db.turso.io"
+                : "file:./payload.db",
+        NEXT_PUBLIC_SITE_NAME: "Blog",
+        NEXT_PUBLIC_SITE_URL: "http://localhost:3000",
+        NEXT_PUBLIC_BLOG_ROUTE_PREFIX: routePrefix,
+    };
+    if (options.db === "turso") {
+        base.PAYLOAD_DATABASE_AUTH_TOKEN = "replace-with-turso-token";
+    }
+    if (options.db === "postgres") {
+        base.PAYLOAD_DATABASE_SCHEMA = (_b = options.postgresSchema) !== null && _b !== void 0 ? _b : "payload";
+    }
+    if (options.storage === "s3") {
+        Object.assign(base, {
+            S3_BUCKET: "",
+            S3_REGION: "",
+            S3_ACCESS_KEY_ID: "",
+            S3_SECRET_ACCESS_KEY: "",
+            PAYLOAD_MEDIA_PREFIX: "blog",
+        });
+    }
+    if (options.storage === "r2") {
+        Object.assign(base, {
+            R2_BUCKET: "",
+            R2_ACCOUNT_ID: "",
+            R2_ACCESS_KEY_ID: "",
+            R2_SECRET_ACCESS_KEY: "",
+            PAYLOAD_MEDIA_PREFIX: "blog",
+        });
+    }
+    if (options.storage === "vercel-blob") {
+        base.BLOB_READ_WRITE_TOKEN = "";
+    }
+    if (options.storage === "azure") {
+        base.AZURE_STORAGE_CONNECTION_STRING = "";
+        base.AZURE_STORAGE_CONTAINER_NAME = "";
+    }
+    if (options.storage === "gcs") {
+        base.GCS_BUCKET = "";
+        base.GCS_PROJECT_ID = "";
+    }
+    if (options.storage === "uploadthing") {
+        base.UPLOADTHING_TOKEN = "";
+    }
+    for (const [key, value] of Object.entries((_c = options.env) !== null && _c !== void 0 ? _c : {})) {
+        if (typeof value !== "string")
+            continue;
+        base[key] =
+            key === "NEXT_PUBLIC_BLOG_ROUTE_PREFIX"
+                ? normalizeInstallRoutePrefix(value)
+                : value;
+    }
+    return base;
+}
+function installScripts() {
+    return {
+        "payload:migrate": "payload migrate",
+        "payload:migrate:create": "payload migrate:create",
+        "payload:generate-types": "payload generate:types",
+    };
+}
+function assertNoGeneratedFileCollisions(projectRoot, changes) {
+    const collisions = changes.filter((change) => change.kind === "create" && existsSync(join(projectRoot, change.path)));
+    if (collisions.length > 0) {
+        throw new Error(`Refusing to install because generated files already exist: ${collisions
+            .map((change) => change.path)
+            .join(", ")}. Move those files or choose different installer paths before applying.`);
+    }
+}
+function nonNextIntegrationReadme(options) {
+    var _a, _b;
+    const routePrefix = normalizeInstallRoutePrefix((_a = options.routePrefix) !== null && _a !== void 0 ? _a : "/blog");
+    const adminPath = normalizeInstallAdminPath((_b = options.adminPath) !== null && _b !== void 0 ? _b : "/cms");
+    return `# FounderHQ Payload Blog Kit
+
+This project is not a Next.js App Router app, so the installer generated the
+Payload CMS and framework-neutral blog data helpers only.
+
+## Generated files
+
+- \`payload.config.ts\`: Payload CMS config with FounderHQ blog collections.
+- \`founderhq-blog.storage.ts\`: selected Payload upload storage adapter.
+- \`founderhq-blog.ts\`: framework-neutral fetch helpers and site tokens.
+
+## Routes to wire in your framework
+
+- Payload REST API: \`/api/*\`
+- Payload admin: \`${adminPath}\`
+- Blog index: \`${routePrefix}\`
+- Blog index pagination: \`${routePrefix}/page/:page\`
+- Blog article: \`${routePrefix}/:slug\`
+- Blog search: \`${routePrefix}/search?q=term\`
+- Author directory: \`${routePrefix}/authors\`
+- Author archive: \`${routePrefix}/authors/:slug\`
+- Author archive pagination: \`${routePrefix}/authors/:slug/page/:page\`
+- Category directory: \`${routePrefix}/categories\`
+- Category archive: \`${routePrefix}/categories/:slug\`
+- Category archive pagination: \`${routePrefix}/categories/:slug/page/:page\`
+- Tag directory: \`${routePrefix}/tags\`
+- Tag archive: \`${routePrefix}/tags/:slug\`
+- Tag archive pagination: \`${routePrefix}/tags/:slug/page/:page\`
+- RSS feed: \`${routePrefix}/rss.xml\`
+- Sitemap index: \`/sitemap.xml\`
+- Blog sitemap URL sets:
+  - \`/sitemaps/blog-posts.xml\`
+  - \`/sitemaps/blog-authors.xml\`
+  - \`/sitemaps/blog-categories.xml\`
+  - \`/sitemaps/blog-tags.xml\`
+
+Use \`@founderhq/next-blog/server\` for URL, metadata, JSON-LD, RSS, sitemap,
+search, and Payload REST helpers. The React templates are intentionally not
+installed because this project is not a supported Next App Router surface.
+`;
+}
+function createManualInstallPlan(options, pkg) {
+    var _a, _b;
+    const routePrefix = normalizeInstallRoutePrefix((_a = options.routePrefix) !== null && _a !== void 0 ? _a : "/blog");
+    const adminPath = normalizeInstallAdminPath((_b = options.adminPath) !== null && _b !== void 0 ? _b : "/cms");
+    const resolvedOptions = Object.assign(Object.assign({}, options), { adminPath, routePrefix });
+    const existingPayloadConfigPath = existingPayloadConfig(options.projectRoot);
+    if (existingPayloadConfigPath) {
+        throw new Error(`Existing ${existingPayloadConfigPath} was found. The installer will not overwrite an existing Payload config. Add @founderhq/payload-cms-kit manually with createFounderHQBlogCollections(), or move the existing config before running the installer.`);
+    }
+    const env = envEntries(resolvedOptions);
+    const changes = [
+        {
+            kind: "create",
+            path: "payload.config.ts",
+            content: payloadConfig(resolvedOptions),
+        },
+        {
+            kind: "create",
+            path: "founderhq-blog.storage.ts",
+            content: storageFile(resolvedOptions.storage),
+        },
+        tsconfigChange(options.projectRoot),
+        {
+            kind: "create",
+            path: "founderhq-blog.ts",
+            content: blogDataFile(),
+        },
+        {
+            kind: "create",
+            path: "FOUNDERHQ_BLOG_INTEGRATION.md",
+            content: nonNextIntegrationReadme(resolvedOptions),
+        },
+    ];
+    assertNoGeneratedFileCollisions(options.projectRoot, changes);
+    const dependencies = Object.assign(Object.assign(Object.assign({}, COMMON_DEPENDENCIES), DB_DEPENDENCIES[resolvedOptions.db]), STORAGE_DEPENDENCIES[resolvedOptions.storage]);
+    const devDependencies = {};
+    const warnings = [
+        "This project is not a Next.js App Router app. The installer generated Payload and framework-neutral helpers only; wire the public routes in your framework.",
+        "The installer uses PAYLOAD_DATABASE_URL and never reuses DATABASE_URL automatically.",
+        "Review generated Payload files before running migrations against production data.",
+        ...(resolvedOptions.storage === "custom"
+            ? [
+                "Custom/manual storage selected. founderhq-blog.storage.ts starts as a no-op so migrations and admin boot; add your storage adapter before production uploads.",
+            ]
+            : []),
+    ];
+    return {
+        appDir: "manual",
+        dependencies,
+        devDependencies,
+        env,
+        changes,
+        scripts: installScripts(),
+        installCommand: installCommandForPlan(options.projectRoot, pkg, dependencies, devDependencies),
+        migrationCommand: resolvedOptions.migration === "run"
+            ? packageManagerRunScript(options.projectRoot, pkg, "payload:migrate")
+            : null,
+        warnings,
+    };
+}
+export function createInstallPlan(options) {
+    var _a, _b;
+    const pkgPath = join(options.projectRoot, "package.json");
+    const pkg = readJson(pkgPath);
+    if (!pkg)
+        throw new Error("package.json was not found or is invalid.");
+    if (!hasDependency(pkg, "next")) {
+        return createManualInstallPlan(options, pkg);
+    }
+    const existingPayloadConfigPath = existingPayloadConfig(options.projectRoot);
+    if (existingPayloadConfigPath) {
+        throw new Error(`Existing ${existingPayloadConfigPath} was found. The v1 installer will not overwrite an existing Payload config. Add @founderhq/payload-cms-kit manually with founderHQBlogPlugin(), or move the existing config before running the installer.`);
+    }
+    const appDir = detectAppDir(options.projectRoot);
+    if (!appDir) {
+        throw new Error("No app/ or src/app/ directory found.");
+    }
+    const routePrefix = normalizeInstallRoutePrefix((_a = options.routePrefix) !== null && _a !== void 0 ? _a : "/blog");
+    const adminPath = normalizeInstallAdminPath((_b = options.adminPath) !== null && _b !== void 0 ? _b : "/cms");
+    const resolvedOptions = Object.assign(Object.assign({}, options), { adminPath, routePrefix });
+    const routeSegment = routePrefix.replace(/^\/+/, "").replace(/\/+$/, "") || "blog";
+    const adminSegment = adminPath.replace(/^\/+/, "").replace(/\/+$/, "") || "cms";
+    const env = envEntries(resolvedOptions);
+    const sourceRoot = appDir.endsWith(join("src", "app"))
+        ? join(options.projectRoot, "src")
+        : options.projectRoot;
+    const libDir = join(sourceRoot, "lib");
+    const blogComponentsPath = join(sourceRoot, "components", "blog", "blog-components.tsx");
+    const blogStylesPath = join(sourceRoot, "components", "blog", "blog.css");
+    const blogDataPath = join(libDir, "founderhq-blog.ts");
+    const indexPagePath = join(appDir, routeSegment, "page.tsx");
+    const paginatedIndexPagePath = join(appDir, routeSegment, "page", "[page]", "page.tsx");
+    const articlePagePath = join(appDir, routeSegment, "[slug]", "page.tsx");
+    const searchPagePath = join(appDir, routeSegment, "search", "page.tsx");
+    const authorsPagePath = join(appDir, routeSegment, "authors", "page.tsx");
+    const authorArchivePagePath = join(appDir, routeSegment, "authors", "[slug]", "page.tsx");
+    const authorPaginatedArchivePagePath = join(appDir, routeSegment, "authors", "[slug]", "page", "[page]", "page.tsx");
+    const categoriesPagePath = join(appDir, routeSegment, "categories", "page.tsx");
+    const categoryArchivePagePath = join(appDir, routeSegment, "categories", "[slug]", "page.tsx");
+    const categoryPaginatedArchivePagePath = join(appDir, routeSegment, "categories", "[slug]", "page", "[page]", "page.tsx");
+    const tagsPagePath = join(appDir, routeSegment, "tags", "page.tsx");
+    const tagArchivePagePath = join(appDir, routeSegment, "tags", "[slug]", "page.tsx");
+    const tagPaginatedArchivePagePath = join(appDir, routeSegment, "tags", "[slug]", "page", "[page]", "page.tsx");
+    const rssRoutePath = join(appDir, routeSegment, "rss.xml", "route.ts");
+    const blogPostsSitemapRoutePath = join(appDir, "sitemaps", "blog-posts.xml", "route.ts");
+    const blogAuthorsSitemapRoutePath = join(appDir, "sitemaps", "blog-authors.xml", "route.ts");
+    const blogCategoriesSitemapRoutePath = join(appDir, "sitemaps", "blog-categories.xml", "route.ts");
+    const blogTagsSitemapRoutePath = join(appDir, "sitemaps", "blog-tags.xml", "route.ts");
+    const rootSitemapRoutePath = join(appDir, "sitemap.xml", "route.ts");
+    const metadataSitemapPath = [
+        join(appDir, "sitemap.ts"),
+        join(appDir, "sitemap.tsx"),
+        join(appDir, "sitemap.js"),
+    ].find((path) => existsSync(path));
+    const robotsPath = [
+        join(appDir, "robots.ts"),
+        join(appDir, "robots.tsx"),
+        join(appDir, "robots.js"),
+    ].find((path) => existsSync(path));
+    const rootRobotsPath = join(appDir, "robots.ts");
+    const staticRobotsPath = join(options.projectRoot, "public", "robots.txt");
+    const staticSitemapPath = join(options.projectRoot, "public", "sitemap.xml");
+    const childSitemapUrls = [
+        "/sitemaps/blog-posts.xml",
+        "/sitemaps/blog-authors.xml",
+        "/sitemaps/blog-categories.xml",
+        "/sitemaps/blog-tags.xml",
+    ].map((path) => absoluteFromSite(env.NEXT_PUBLIC_SITE_URL, path));
+    const payloadGroupDir = join(appDir, "(payload)");
+    const payloadAdminDir = join(payloadGroupDir, adminSegment);
+    const relativeApp = (path) => relative(options.projectRoot, path);
+    const configPatch = nextConfigChange(options.projectRoot);
+    const blogTemplates = createEditableBlogTemplates();
+    const blogComponents = blogTemplates.find((template) => template.name === "components");
+    const blogStyles = blogTemplates.find((template) => template.name === "styles");
+    if (!blogComponents || !blogStyles) {
+        throw new Error("FounderHQ editable blog templates are incomplete.");
+    }
+    const robotsChanges = [];
+    const robotsWarnings = [];
+    if (robotsPath) {
+        const existing = readFileSync(robotsPath, "utf8");
+        if (!existing.includes("sitemap")) {
+            const patched = patchMetadataRobots(existing, absoluteFromSite(env.NEXT_PUBLIC_SITE_URL, "/sitemap.xml"));
+            if (patched) {
+                robotsChanges.push({
+                    kind: "update",
+                    path: relativeApp(robotsPath),
+                    content: patched,
+                });
+            }
+            else {
+                robotsWarnings.push("Existing app/robots metadata file could not be patched safely and does not appear to define a sitemap. Add your root /sitemap.xml URL to robots manually.");
+            }
+        }
+    }
+    else if (existsSync(staticRobotsPath)) {
+        const existing = readFileSync(staticRobotsPath, "utf8");
+        if (!/sitemap\s*:/i.test(existing)) {
+            robotsChanges.push({
+                kind: "update",
+                path: relativeApp(staticRobotsPath),
+                content: patchStaticRobots(existing, absoluteFromSite(env.NEXT_PUBLIC_SITE_URL, "/sitemap.xml")),
+            });
+        }
+    }
+    else {
+        robotsChanges.push({
+            kind: "create",
+            path: relativeApp(rootRobotsPath),
+            content: robotsMetadataRoute(importPath(rootRobotsPath, blogDataPath)),
+        });
+    }
+    const sitemapChanges = [
+        {
+            kind: "create",
+            path: relativeApp(blogPostsSitemapRoutePath),
+            content: blogPostsSitemapRoute(importPath(blogPostsSitemapRoutePath, blogDataPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(blogAuthorsSitemapRoutePath),
+            content: blogTaxonomySitemapRoute("authors", importPath(blogAuthorsSitemapRoutePath, blogDataPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(blogCategoriesSitemapRoutePath),
+            content: blogTaxonomySitemapRoute("categories", importPath(blogCategoriesSitemapRoutePath, blogDataPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(blogTagsSitemapRoutePath),
+            content: blogTaxonomySitemapRoute("tags", importPath(blogTagsSitemapRoutePath, blogDataPath)),
+        },
+    ];
+    const sitemapWarnings = [];
+    if (metadataSitemapPath) {
+        const existing = readFileSync(metadataSitemapPath, "utf8");
+        const patched = patchMetadataSitemap(existing, importPath(metadataSitemapPath, blogDataPath));
+        if (patched) {
+            sitemapChanges.push({
+                kind: "update",
+                path: relativeApp(metadataSitemapPath),
+                content: patched,
+            });
+        }
+        else {
+            sitemapWarnings.push("Existing app/sitemap metadata file could not be patched safely. The blog child sitemaps were generated at /sitemaps/blog-*.xml; add their indexable blog URLs to your existing sitemap manually.");
+        }
+    }
+    else if (existsSync(rootSitemapRoutePath)) {
+        const existing = readFileSync(rootSitemapRoutePath, "utf8");
+        if (!childSitemapUrls.every((url) => existing.includes(url)) && ![
+            "/sitemaps/blog-posts.xml",
+            "/sitemaps/blog-authors.xml",
+            "/sitemaps/blog-categories.xml",
+            "/sitemaps/blog-tags.xml",
+        ].every((url) => existing.includes(url))) {
+            sitemapWarnings.push("Existing app/sitemap.xml/route.ts was left unchanged because it could not be patched safely. Add the generated /sitemaps/blog-*.xml URLs to that sitemap index manually.");
+        }
+    }
+    else if (existsSync(staticSitemapPath)) {
+        const existing = readFileSync(staticSitemapPath, "utf8");
+        const patched = patchStaticSitemapIndex(existing, childSitemapUrls);
+        if (patched) {
+            sitemapChanges.push({
+                kind: "update",
+                path: relativeApp(staticSitemapPath),
+                content: patched,
+            });
+        }
+        else {
+            sitemapWarnings.push("Existing public/sitemap.xml could not be patched safely. The blog child sitemaps were generated at /sitemaps/blog-*.xml; add them to the sitemap index manually, or convert a static URL set into a sitemap index.");
+        }
+    }
+    else {
+        sitemapChanges.push({
+            kind: "create",
+            path: relativeApp(rootSitemapRoutePath),
+            content: rootSitemapIndexRoute(importPath(rootSitemapRoutePath, blogDataPath)),
+        });
+    }
+    const changes = [
+        {
+            kind: "create",
+            path: "payload.config.ts",
+            content: payloadConfig(resolvedOptions),
+        },
+        {
+            kind: "create",
+            path: "founderhq-blog.storage.ts",
+            content: storageFile(resolvedOptions.storage),
+        },
+        tsconfigChange(options.projectRoot),
+        ...(configPatch ? [configPatch] : []),
+        {
+            kind: "create",
+            path: relativeApp(join(payloadGroupDir, "api", "[...slug]", "route.ts")),
+            content: payloadRestRoute(),
+        },
+        {
+            kind: "create",
+            path: relativeApp(join(payloadGroupDir, "layout.tsx")),
+            content: payloadLayout(adminSegment),
+        },
+        {
+            kind: "create",
+            path: relativeApp(join(payloadGroupDir, "custom.css")),
+            content: "",
+        },
+        {
+            kind: "create",
+            path: relativeApp(join(payloadAdminDir, "importMap.js")),
+            content: payloadImportMap(),
+        },
+        {
+            kind: "create",
+            path: relativeApp(join(payloadAdminDir, "[[...segments]]", "page.tsx")),
+            content: payloadAdminPage(),
+        },
+        {
+            kind: "create",
+            path: relativeApp(blogDataPath),
+            content: blogDataFile(),
+        },
+        {
+            kind: "create",
+            path: relativeApp(blogComponentsPath),
+            content: blogComponents.content,
+        },
+        {
+            kind: "create",
+            path: relativeApp(blogStylesPath),
+            content: blogStyles.content,
+        },
+        {
+            kind: "create",
+            path: relativeApp(indexPagePath),
+            content: blogIndexPage(importPath(indexPagePath, blogDataPath), importPath(indexPagePath, blogComponentsPath), importPath(indexPagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(paginatedIndexPagePath),
+            content: blogPaginatedIndexPage(importPath(paginatedIndexPagePath, blogDataPath), importPath(paginatedIndexPagePath, blogComponentsPath), importPath(paginatedIndexPagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(articlePagePath),
+            content: blogArticlePage(importPath(articlePagePath, blogDataPath), importPath(articlePagePath, blogComponentsPath), importPath(articlePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(searchPagePath),
+            content: blogSearchPage(importPath(searchPagePath, blogDataPath), importPath(searchPagePath, blogComponentsPath), importPath(searchPagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(authorsPagePath),
+            content: blogDirectoryPage("authors", importPath(authorsPagePath, blogDataPath), importPath(authorsPagePath, blogComponentsPath), importPath(authorsPagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(authorArchivePagePath),
+            content: blogArchivePage("author", false, importPath(authorArchivePagePath, blogDataPath), importPath(authorArchivePagePath, blogComponentsPath), importPath(authorArchivePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(authorPaginatedArchivePagePath),
+            content: blogArchivePage("author", true, importPath(authorPaginatedArchivePagePath, blogDataPath), importPath(authorPaginatedArchivePagePath, blogComponentsPath), importPath(authorPaginatedArchivePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(categoriesPagePath),
+            content: blogDirectoryPage("categories", importPath(categoriesPagePath, blogDataPath), importPath(categoriesPagePath, blogComponentsPath), importPath(categoriesPagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(categoryArchivePagePath),
+            content: blogArchivePage("category", false, importPath(categoryArchivePagePath, blogDataPath), importPath(categoryArchivePagePath, blogComponentsPath), importPath(categoryArchivePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(categoryPaginatedArchivePagePath),
+            content: blogArchivePage("category", true, importPath(categoryPaginatedArchivePagePath, blogDataPath), importPath(categoryPaginatedArchivePagePath, blogComponentsPath), importPath(categoryPaginatedArchivePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(tagsPagePath),
+            content: blogDirectoryPage("tags", importPath(tagsPagePath, blogDataPath), importPath(tagsPagePath, blogComponentsPath), importPath(tagsPagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(tagArchivePagePath),
+            content: blogArchivePage("tag", false, importPath(tagArchivePagePath, blogDataPath), importPath(tagArchivePagePath, blogComponentsPath), importPath(tagArchivePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(tagPaginatedArchivePagePath),
+            content: blogArchivePage("tag", true, importPath(tagPaginatedArchivePagePath, blogDataPath), importPath(tagPaginatedArchivePagePath, blogComponentsPath), importPath(tagPaginatedArchivePagePath, blogStylesPath)),
+        },
+        {
+            kind: "create",
+            path: relativeApp(rssRoutePath),
+            content: rssRoute(importPath(rssRoutePath, blogDataPath)),
+        },
+        ...sitemapChanges,
+        ...robotsChanges,
+    ];
+    assertNoGeneratedFileCollisions(options.projectRoot, changes);
+    const dependencies = Object.assign(Object.assign(Object.assign({}, NEXT_DEPENDENCIES), DB_DEPENDENCIES[resolvedOptions.db]), STORAGE_DEPENDENCIES[resolvedOptions.storage]);
+    const devDependencies = {};
+    const warnings = [
+        "The installer uses PAYLOAD_DATABASE_URL and never reuses DATABASE_URL automatically.",
+        "Review generated Payload files before running migrations against production data.",
+        ...(configPatch
+            ? []
+            : [
+                "next.config could not be patched automatically because it is not an ESM export-default config. Wrap it with withPayload manually.",
+            ]),
+        ...(resolvedOptions.storage === "custom"
+            ? [
+                "Custom/manual storage selected. founderhq-blog.storage.ts starts as a no-op so migrations and admin boot; add your storage adapter before production uploads.",
+            ]
+            : []),
+        ...sitemapWarnings,
+        ...robotsWarnings,
+    ];
+    return {
+        appDir: relativeApp(appDir),
+        dependencies,
+        devDependencies,
+        env,
+        changes,
+        scripts: installScripts(),
+        installCommand: installCommandForPlan(options.projectRoot, pkg, dependencies, devDependencies),
+        migrationCommand: resolvedOptions.migration === "run"
+            ? packageManagerRunScript(options.projectRoot, pkg, "payload:migrate")
+            : null,
+        warnings,
+    };
+}
+//# sourceMappingURL=core.js.map