@karaoke-cms/astro 0.6.3 → 0.9.1

package/src/index.ts

@@ -1,24 +1,45 @@
 import type { AstroIntegration } from 'astro';
-import { fileURLToPath } from 'url';
-import { join, resolve, isAbsolute } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolve, isAbsolute } from 'path';
+import { createRequire } from 'module';
 import { wikiLinkPlugin } from 'remark-wiki-link';
 import sitemap from '@astrojs/sitemap';
-import { getTheme, validateModules } from './validate-config.js';
+import { validateModules } from './validate-config.js';
 import { resolveModules } from './utils/resolve-modules.js';
 import { resolveLayout } from './utils/resolve-layout.js';
 import { resolveCollections } from './utils/resolve-collections.js';
-import type { KaraokeConfig, ResolvedModules, ResolvedLayout, ResolvedCollections } from './types.js';
+import { resolveMenus } from './utils/resolve-menus.js';
+import type { KaraokeConfig, ResolvedModules, ResolvedLayout, ResolvedCollections, ResolvedMenus, ThemeInstance } from './types.js';
 
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
+function isThemeInstance(theme: unknown): theme is ThemeInstance {
+  return typeof theme === 'object' && theme !== null &&
+    (theme as ThemeInstance)._type === 'theme-instance';
+}
+
+/**
+ * Resolve a theme config value to an npm package name.
+ * Bare strings ('default', 'minimal') map to @karaoke-cms/theme-* with a deprecation warning.
+ */
+function resolveThemePkg(theme: string | undefined): string {
+  const raw = theme ?? '@karaoke-cms/theme-default';
+  if (raw === 'default' || raw === 'minimal') {
+    console.warn(
+      `[karaoke-cms] theme: '${raw}' is deprecated. Use theme: '@karaoke-cms/theme-${raw}' instead.`,
+    );
+    return `@karaoke-cms/theme-${raw}`;
+  }
+  return raw;
+}
 
 /**
  * karaoke() — the main Astro integration for karaoke-cms.
  *
- * Injects all routes (/, /blog, /blog/[slug], /docs, /docs/[slug],
- * /tags, /tags/[tag], /rss.xml, /404), sets up the @theme CSS alias,
- * enables wikilinks, and provides a virtual module with your resolved config.
+ * Loads the active theme package (an Astro integration) and registers it
+ * as a nested integration. The theme owns all content routes (/, /blog, /docs,
+ * etc.), the @theme CSS alias, and its own 404 page.
  *
- * The /karaoke-cms and /karaoke-cms/[...slug] routes are injected in dev only.
+ * Core always registers: /rss.xml, /karaoke-cms/[...slug] (dev only), wikilinks,
+ * sitemap, and the virtual:karaoke-cms/config module.
  *
  * @example
  * // astro.config.mjs
@@ -30,63 +51,78 @@ const __dirname = fileURLToPath(new URL('.', import.meta.url));
  *   site: 'https://your-site.pages.dev',
  *   integrations: [karaoke(karaokeConfig)],
  * });
- *
- * Module slots (contract for Base.astro — extensible in v0.7+):
- *   'nav'         — rendered in the nav bar (e.g., Search)
- *   'post-footer' — rendered after post content (e.g., Comments)
  */
+/** Identity wrapper for karaoke.config.ts — provides type inference. */
+export function defineConfig(config: KaraokeConfig): KaraokeConfig {
+  return config;
+}
+
 export default function karaoke(config: KaraokeConfig = {}): AstroIntegration {
-  const themesDir = join(__dirname, 'themes');
-  const theme = getTheme(config, themesDir);
   validateModules(config);
   const resolved = resolveModules(config);
   const layout = resolveLayout(config);
 
+  let _resolvedCollections: ResolvedCollections | undefined;
+
   return {
     name: '@karaoke-cms/astro',
     hooks: {
-      'astro:config:setup'({ injectRoute, updateConfig, command, config: astroConfig }) {
+      async 'astro:config:setup'({ injectRoute, updateConfig, command, config: astroConfig }) {
         const rootDir = fileURLToPath(astroConfig.root);
         const vaultDir = config.vault
           ? (isAbsolute(config.vault) ? config.vault : resolve(rootDir, config.vault))
           : rootDir;
         const isProd = command === 'build';
-        const resolvedCollections = resolveCollections(vaultDir, isProd, config.collections);
+        _resolvedCollections = resolveCollections(vaultDir, isProd, config.collections);
+        const _resolvedMenus = resolveMenus(vaultDir);
+
+        // ── Load active theme as a nested Astro integration ───────────────
+        let themeIntegration: AstroIntegration;
+
+        if (isThemeInstance(config.theme)) {
+          // New API: theme is a ThemeInstance from defineTheme()
+          themeIntegration = config.theme.toAstroIntegration();
+        } else {
+          // Legacy API: theme is a package name string.
+          // Resolve from the user's project root so their node_modules is searched.
+          const themePkg = resolveThemePkg(config.theme as string | undefined);
+          const projectRequire = createRequire(new URL('package.json', astroConfig.root));
+          let resolvedThemePath: string;
+          try {
+            resolvedThemePath = projectRequire.resolve(themePkg);
+          } catch {
+            throw new Error(
+              `[karaoke-cms] Theme package "${themePkg}" is not installed.\n` +
+              `Run: pnpm add ${themePkg}`,
+            );
+          }
+          // Use new Function to bypass Vite's import() interception —
+          // this runs the native Node.js ESM loader, not Vite's module runner.
+          const nativeImport: (specifier: string) => Promise<unknown> =
+            new Function('specifier', 'return import(specifier)');
+          const themeModule = await nativeImport(pathToFileURL(resolvedThemePath).href) as {
+            default: (cfg: KaraokeConfig) => AstroIntegration;
+          };
+          themeIntegration = themeModule.default(config);
+        }
 
-        // ── Inject all framework routes ──────────────────────────────────
-        injectRoute({ pattern: '/', entrypoint: '@karaoke-cms/astro/pages/index.astro' });
-        injectRoute({ pattern: '/blog', entrypoint: '@karaoke-cms/astro/pages/blog/index.astro' });
-        injectRoute({ pattern: '/blog/[slug]', entrypoint: '@karaoke-cms/astro/pages/blog/[slug].astro' });
-        injectRoute({ pattern: '/docs', entrypoint: '@karaoke-cms/astro/pages/docs/index.astro' });
-        injectRoute({ pattern: '/docs/[slug]', entrypoint: '@karaoke-cms/astro/pages/docs/[slug].astro' });
-        injectRoute({ pattern: '/tags', entrypoint: '@karaoke-cms/astro/pages/tags/index.astro' });
-        injectRoute({ pattern: '/tags/[tag]', entrypoint: '@karaoke-cms/astro/pages/tags/[tag].astro' });
-        injectRoute({ pattern: '/404', entrypoint: '@karaoke-cms/astro/pages/404.astro' });
+        // ── Core routes — always present regardless of theme ─────────────
         injectRoute({ pattern: '/rss.xml', entrypoint: '@karaoke-cms/astro/pages/rss.xml.ts' });
 
-        // ── Handbook routes — dev only ───────────────────────────────────
-        if (resolvedCollections['karaoke-cms']?.enabled) {
+        // Handbook routes — dev only
+        if (_resolvedCollections['karaoke-cms']?.enabled) {
           injectRoute({ pattern: '/karaoke-cms', entrypoint: '@karaoke-cms/astro/pages/karaoke-cms/index.astro' });
           injectRoute({ pattern: '/karaoke-cms/[...slug]', entrypoint: '@karaoke-cms/astro/pages/karaoke-cms/[...slug].astro' });
         }
 
         updateConfig({
-          integrations: [sitemap()],
+          integrations: [sitemap(), themeIntegration],
           vite: {
-            resolve: {
-              alias: {
-                // @theme → packages/astro/src/themes/<active-theme>/
-                '@theme': join(themesDir, theme),
-              },
-            },
-            plugins: [virtualConfigPlugin(config, resolved, layout, resolvedCollections)],
+            plugins: [virtualConfigPlugin(config, resolved, layout, _resolvedCollections, _resolvedMenus)],
           },
           markdown: {
             remarkPlugins: [
               [wikiLinkPlugin, {
-                // [[blog/hello-world]] → /blog/hello-world/
-                // [[docs/getting-started]] → /docs/getting-started/
-                // [[blog/hello-world|Hello World]] → link text "Hello World"
                 pageResolver: (name: string) => [name.toLowerCase().replace(/ /g, '-')],
                 hrefTemplate: (permalink: string) => `/${permalink}/`,
                 aliasDivider: '|',
@@ -95,6 +131,19 @@ export default function karaoke(config: KaraokeConfig = {}): AstroIntegration {
           },
         });
       },
+
+      'astro:build:done'({ pages }) {
+        if (!_resolvedCollections?.docs?.enabled) return;
+        // pages is { pathname: string }[] — check if any /docs page was rendered
+        const hasDocsRoute = (pages ?? []).some(p => p.pathname?.startsWith('docs'));
+        if (!hasDocsRoute) {
+          console.warn(
+            '[karaoke-cms] Your vault has a docs collection enabled but the active theme ' +
+            'has no /docs route. Published docs entries will not be accessible. ' +
+            'Consider using @karaoke-cms/theme-default which includes /docs routes.',
+          );
+        }
+      },
     },
   };
 }
@@ -108,6 +157,7 @@ function virtualConfigPlugin(
   resolved: ResolvedModules,
   layout: ResolvedLayout,
   resolvedCollections: ResolvedCollections,
+  resolvedMenus: ResolvedMenus,
 ) {
   const VIRTUAL_ID = 'virtual:karaoke-cms/config';
   const RESOLVED_ID = '\0' + VIRTUAL_ID;
@@ -125,10 +175,14 @@ export const siteDescription = ${JSON.stringify(config.description ?? '')};
 export const resolvedModules = ${JSON.stringify(resolved)};
 export const resolvedLayout = ${JSON.stringify(layout)};
 export const resolvedCollections = ${JSON.stringify(resolvedCollections)};
+export const resolvedMenus = ${JSON.stringify(resolvedMenus)};
 `;
       }
     },
   };
 }
 
-export type { KaraokeConfig, ResolvedModules, ResolvedLayout, ResolvedCollections, RegionComponent } from './types.js';
+export { defineModule } from './define-module.js';
+export { defineTheme } from './define-theme.js';
+export type { ModuleInstance, ThemeInstance, ModuleMenuEntry } from './types.js';
+export type { KaraokeConfig, ResolvedModules, ResolvedLayout, ResolvedCollections, RegionComponent, ResolvedMenus, ResolvedMenu, ResolvedMenuEntry } from './types.js';

package/src/layouts/Base.astro

@@ -1,8 +1,7 @@
 ---
 import '@theme/styles.css';
 import RegionRenderer from '../components/RegionRenderer.astro';
-import { resolvedModules, resolvedLayout } from 'virtual:karaoke-cms/config';
-import { SITE_TITLE } from '../consts';
+import { siteTitle, resolvedModules, resolvedLayout } from 'virtual:karaoke-cms/config';
 
 interface Props {
   title: string;
@@ -28,14 +27,14 @@ const hasRight = Astro.slots.has('right') || layout.regions.right.components.len
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="icon" href="/favicon.ico" />
     <meta name="generator" content={Astro.generator} />
-    <title>{title === SITE_TITLE ? title : `${title} — ${SITE_TITLE}`}</title>
+    <title>{title === siteTitle ? title : `${title} — ${siteTitle}`}</title>
     {description && <meta name="description" content={description} />}
     <meta property="og:title" content={title} />
     <meta property="og:type" content={type} />
     <meta property="og:url" content={canonicalUrl} />
     {description && <meta property="og:description" content={description} />}
     <meta name="twitter:card" content="summary" />
-    <link rel="alternate" type="application/rss+xml" title={SITE_TITLE} href="/rss.xml" />
+    <link rel="alternate" type="application/rss+xml" title={siteTitle} href="/rss.xml" />
   </head>
   <body>
     <header>
@@ -65,9 +64,11 @@ const hasRight = Astro.slots.has('right') || layout.regions.right.components.len
       )}
     </div>
     <footer>
-      <slot name="bottom">
-        <RegionRenderer components={layout.regions.bottom.components} {searchEnabled} />
-      </slot>
+      <div class="footer-inner">
+        <slot name="bottom">
+          <RegionRenderer components={layout.regions.bottom.components} {searchEnabled} />
+        </slot>
+      </div>
     </footer>
   </body>
 </html>

package/src/types.ts

@@ -29,8 +29,8 @@ export interface KaraokeConfig {
   title?: string;
   /** Site description — used in RSS feed and OG meta tags. */
   description?: string;
-  /** Theme name — must match a folder in themes/. Defaults to 'default'. */
-  theme?: string;
+  /** Theme — package name string (legacy) or a ThemeInstance from defineTheme(). */
+  theme?: string | ThemeInstance;
   modules?: {
     search?: { enabled?: boolean };
     comments?: {
@@ -73,3 +73,67 @@ export interface ResolvedLayout {
     bottom: { components: RegionComponent[] };
   };
 }
+
+// ── Menu types ─────────────────────────────────────────────────────────────────
+
+/** Raw shape of one entry in menus.yaml (used to type the parsed YAML). */
+export interface MenuEntryConfig {
+  text: string;
+  href?: string;
+  weight?: number;
+  /** Visibility condition — only 'collection:name' supported in v1. */
+  when?: string;
+  entries?: MenuEntryConfig[];
+}
+
+/** Raw shape of one menu block in menus.yaml. */
+export interface MenuConfig {
+  orientation?: 'horizontal' | 'vertical';
+  entries?: MenuEntryConfig[];
+}
+
+export interface ResolvedMenuEntry {
+  text: string;
+  href?: string;
+  weight: number;
+  when?: string;
+  entries: ResolvedMenuEntry[];
+}
+
+export interface ResolvedMenu {
+  name: string;
+  orientation: 'horizontal' | 'vertical';
+  entries: ResolvedMenuEntry[];
+}
+
+export type ResolvedMenus = Record<string, ResolvedMenu>;
+
+// ── Module system types ────────────────────────────────────────────────────────
+
+/** A menu entry registered by a module instance. */
+export interface ModuleMenuEntry {
+  id: string;
+  name: string;
+  path: string;
+  section: string;
+  weight: number;
+}
+
+/** A resolved module instance — returned by a defineModule() factory. */
+export interface ModuleInstance {
+  _type: 'module-instance';
+  id: string;
+  mount: string;
+  routes: Array<{ pattern: string; entrypoint: string }>;
+  menuEntries: ModuleMenuEntry[];
+  cssContract: readonly string[];
+  hasDefaultCss: boolean;
+}
+
+/** A resolved theme instance — returned by a defineTheme() factory. */
+export interface ThemeInstance {
+  _type: 'theme-instance';
+  id: string;
+  implementedModuleIds: string[];
+  toAstroIntegration: () => import('astro').AstroIntegration;
+}

package/src/utils/resolve-menus.ts

@@ -0,0 +1,95 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { parse } from 'yaml';
+import type { MenuConfig, MenuEntryConfig, ResolvedMenuEntry, ResolvedMenu, ResolvedMenus } from '../types.js';
+
+/** Reject javascript: and data: hrefs to prevent stored XSS via menus.yaml. */
+function sanitizeHref(href: string): string | undefined {
+  const lower = href.trim().toLowerCase();
+  if (lower.startsWith('javascript:') || lower.startsWith('data:')) return undefined;
+  return href;
+}
+
+function normalizeEntries(raw: MenuEntryConfig[], depth = 0): ResolvedMenuEntry[] {
+  // Guard against YAML anchor cycles (e.g., entries: &loop ... entries: *loop).
+  if (depth > 10) return [];
+  return (raw ?? [])
+    .map(e => ({
+      text: String(e?.text ?? ''),
+      href: typeof e?.href === 'string' ? sanitizeHref(e.href) : undefined,
+      weight: typeof e?.weight === 'number' ? e.weight : 0,
+      when: typeof e?.when === 'string' ? e.when : undefined,
+      entries: Array.isArray(e?.entries) ? normalizeEntries(e.entries, depth + 1) : [],
+    }))
+    .sort((a, b) => a.weight - b.weight);
+}
+
+function defaultMain(): ResolvedMenu {
+  return {
+    name: 'main',
+    orientation: 'horizontal',
+    entries: [
+      { text: 'Blog', href: '/blog', weight: 10, when: 'collection:blog', entries: [] },
+      { text: 'Docs', href: '/docs', weight: 20, when: 'collection:docs', entries: [] },
+      { text: 'Tags', href: '/tags', weight: 30, entries: [] },
+    ],
+  };
+}
+
+function defaultFooter(): ResolvedMenu {
+  return {
+    name: 'footer',
+    orientation: 'horizontal',
+    entries: [
+      { text: 'RSS', href: '/rss.xml', weight: 10, entries: [] },
+    ],
+  };
+}
+
+/**
+ * Resolve menus from {vault}/karaoke-cms/config/menus.yaml.
+ *
+ * Always ensures `main` and `footer` exist in the result — generating defaults
+ * when absent so that MainMenu.astro and SiteFooter.astro always have something
+ * to render. ENOENT (no menus.yaml) is the normal zero-config case; all other
+ * errors warn and fall back to defaults.
+ */
+export function resolveMenus(vaultDir: string): ResolvedMenus {
+  try {
+    const path = join(vaultDir, 'karaoke-cms/config/menus.yaml');
+    const raw = readFileSync(path, 'utf8');
+    const parsed = parse(raw) as { menus?: Record<string, MenuConfig> };
+
+    if (!parsed?.menus || typeof parsed.menus !== 'object') {
+      return { main: defaultMain(), footer: defaultFooter() };
+    }
+
+    const result: ResolvedMenus = {};
+    for (const [name, cfg] of Object.entries(parsed.menus)) {
+      if (
+        cfg?.orientation !== undefined &&
+        cfg.orientation !== 'horizontal' &&
+        cfg.orientation !== 'vertical'
+      ) {
+        console.warn(
+          `[karaoke-cms] menus.yaml: menu "${name}" has invalid orientation "${cfg.orientation}". Using "horizontal".`,
+        );
+      }
+      result[name] = {
+        name,
+        orientation: cfg?.orientation === 'vertical' ? 'vertical' : 'horizontal',
+        entries: normalizeEntries(cfg?.entries ?? []),
+      };
+    }
+    if (!result.main) result.main = defaultMain();
+    if (!result.footer) result.footer = defaultFooter();
+    return result;
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      console.warn(
+        `[karaoke-cms] Failed to parse menus.yaml: ${(err as Error).message}. Using default menus.`,
+      );
+    }
+    return { main: defaultMain(), footer: defaultFooter() };
+  }
+}

package/src/validate-config.js

@@ -4,18 +4,6 @@
  * Extracted here so the logic is unit-testable separately from astro.config.mjs.
  */
 
-import { readdirSync, statSync } from 'fs'
-import { join } from 'path'
-
-/**
- * Resolve the active theme name from karaoke.config.
- * Falls back to 'default' if config is absent.
- * Throws a clear error if the named theme folder doesn't exist.
- *
- * @param {import('../karaoke.config').KaraokeConfig | null | undefined} config
- * @param {string} themesDir - absolute path to the src/themes directory
- * @returns {string} the resolved theme name
- */
 /**
  * Validate module config at build time.
  * Throws a clear error if comments is enabled but required fields are missing.
@@ -36,24 +24,3 @@ export function validateModules(config) {
   }
 }
 
-export function getTheme(config, themesDir) {
-  const theme = config?.theme ?? 'default'
-  let available
-  try {
-    available = readdirSync(themesDir)
-  } catch {
-    throw new Error(
-      `karaoke-cms: src/themes/ directory not found at ${themesDir} — is this a karaoke-cms repo?`
-    )
-  }
-  available = available.filter(d => {
-    try { return statSync(join(themesDir, d)).isDirectory() } catch { return false }
-  })
-  if (!available.includes(theme)) {
-    throw new Error(
-      `karaoke-cms: theme "${theme}" not found in src/themes/. ` +
-      `Available: ${available.join(', ')}`
-    )
-  }
-  return theme
-}

package/src/pages/404.astro

@@ -1,14 +0,0 @@
----
-import Base from '../layouts/Base.astro';
-import { SITE_TITLE } from '../consts';
----
-
-<Base title={`Page not found — ${SITE_TITLE}`}>
-  <div class="post-header">
-    <h1>Page not found</h1>
-    <p class="post-meta">The page you're looking for doesn't exist or hasn't been published.</p>
-  </div>
-  <div class="prose">
-    <p><a href="/">Go home →</a></p>
-  </div>
-</Base>

package/src/pages/blog/[slug].astro

@@ -1,66 +0,0 @@
----
-import { getCollection, render } from 'astro:content';
-import Base from '../../layouts/Base.astro';
-import ModuleLoader from '../../components/ModuleLoader.astro';
-import { SITE_TITLE } from '../../consts';
-
-export async function getStaticPaths() {
-  const posts = await getCollection('blog', ({ data }) => data.publish === true);
-  return posts.map(entry => ({
-    params: { slug: entry.id },
-    props: { entry },
-  }));
-}
-
-const { entry } = Astro.props;
-const { Content } = await render(entry);
-
-// Resolve related entries by ID across both collections
-const relatedIds = entry.data.related ?? [];
-const related = relatedIds.length > 0
-  ? (await Promise.all([
-      getCollection('blog', ({ data }) => data.publish === true),
-      getCollection('docs', ({ data }) => data.publish === true),
-    ]))
-    .flat()
-    .filter(e => relatedIds.includes(e.id))
-  : [];
----
-
-<Base title={`${entry.data.title} — ${SITE_TITLE}`} description={entry.data.description} type="article">
-  <article>
-    <div class="post-header">
-      <h1>{entry.data.title}</h1>
-      <div class="post-meta">
-        {entry.data.date && <span>{entry.data.date.toISOString().slice(0, 10)}</span>}
-        {entry.data.author && entry.data.date && <span> · </span>}
-        {entry.data.author && (
-          <span>{Array.isArray(entry.data.author) ? entry.data.author.join(' · ') : entry.data.author}</span>
-        )}
-        {entry.data.reading_time && <span> · {entry.data.reading_time} min read</span>}
-      </div>
-    </div>
-    <div class="prose">
-      <Content />
-    </div>
-    <div class="post-footer">
-      {entry.data.tags && entry.data.tags.length > 0 && (
-        <div class="post-tags">
-          {entry.data.tags.map(tag => <a href={`/tags/${tag}`} class="tag">#{tag}</a>)}
-        </div>
-      )}
-      {related.length > 0 && (
-        <div class="related-posts">
-          <p class="related-label">Related</p>
-          <ul>
-            {related.map(r => (
-              <li><a href={`/${r.collection}/${r.id}`}>{r.data.title}</a></li>
-            ))}
-          </ul>
-        </div>
-      )}
-      <a href="/blog">← Blog</a>
-    </div>
-  </article>
-  <ModuleLoader comments={entry.data.comments} />
-</Base>

package/src/pages/blog/index.astro

@@ -1,31 +0,0 @@
----
-import { getCollection } from 'astro:content';
-import Base from '../../layouts/Base.astro';
-import { SITE_TITLE } from '../../consts';
-
-const posts = (await getCollection('blog', ({ data }) => data.publish === true))
-  .sort((a, b) => (b.data.date?.valueOf() ?? 0) - (a.data.date?.valueOf() ?? 0));
----
-
-<Base title={`Blog — ${SITE_TITLE}`}>
-  <div class="listing-header">
-    <h1>Blog</h1>
-  </div>
-  {posts.length > 0 ? (
-    <ul class="post-list">
-      {posts.map(post => (
-        <li>
-          {post.data.date && (
-            <span class="post-date">{post.data.date.toISOString().slice(0, 10)}</span>
-          )}
-          <a href={`/blog/${post.id}`}>{post.data.title}</a>
-        </li>
-      ))}
-    </ul>
-  ) : (
-    <div class="empty-state">
-      <p>No posts published yet.</p>
-      <p>Create a Markdown file in your vault's <code>blog/</code> folder and set <code>publish: true</code> in the frontmatter to make it appear here.</p>
-    </div>
-  )}
-</Base>

package/src/pages/docs/[slug].astro

@@ -1,66 +0,0 @@
----
-import { getCollection, render } from 'astro:content';
-import Base from '../../layouts/Base.astro';
-import ModuleLoader from '../../components/ModuleLoader.astro';
-import { SITE_TITLE } from '../../consts';
-
-export async function getStaticPaths() {
-  const docs = await getCollection('docs', ({ data }) => data.publish === true);
-  return docs.map(entry => ({
-    params: { slug: entry.id },
-    props: { entry },
-  }));
-}
-
-const { entry } = Astro.props;
-const { Content } = await render(entry);
-
-// Resolve related entries by ID across both collections
-const relatedIds = entry.data.related ?? [];
-const related = relatedIds.length > 0
-  ? (await Promise.all([
-      getCollection('blog', ({ data }) => data.publish === true),
-      getCollection('docs', ({ data }) => data.publish === true),
-    ]))
-    .flat()
-    .filter(e => relatedIds.includes(e.id))
-  : [];
----
-
-<Base title={`${entry.data.title} — ${SITE_TITLE}`} description={entry.data.description} type="article">
-  <article>
-    <div class="post-header">
-      <h1>{entry.data.title}</h1>
-      <div class="post-meta">
-        {entry.data.date && <span>{entry.data.date.toISOString().slice(0, 10)}</span>}
-        {entry.data.author && entry.data.date && <span> · </span>}
-        {entry.data.author && (
-          <span>{Array.isArray(entry.data.author) ? entry.data.author.join(' · ') : entry.data.author}</span>
-        )}
-        {entry.data.reading_time && <span> · {entry.data.reading_time} min read</span>}
-      </div>
-    </div>
-    <div class="prose">
-      <Content />
-    </div>
-    <div class="post-footer">
-      {entry.data.tags && entry.data.tags.length > 0 && (
-        <div class="post-tags">
-          {entry.data.tags.map(tag => <a href={`/tags/${tag}`} class="tag">#{tag}</a>)}
-        </div>
-      )}
-      {related.length > 0 && (
-        <div class="related-posts">
-          <p class="related-label">Related</p>
-          <ul>
-            {related.map(r => (
-              <li><a href={`/${r.collection}/${r.id}`}>{r.data.title}</a></li>
-            ))}
-          </ul>
-        </div>
-      )}
-      <a href="/docs">← Docs</a>
-    </div>
-  </article>
-  <ModuleLoader comments={entry.data.comments} />
-</Base>