create-shibumi 0.3.2 → 0.3.6

package/src/templates/blog/gitignore

@@ -1,6 +1,5 @@
 node_modules/
 dist/
-.astro/
 .env
 .env.*
-.DS_Store
+.DS_Store

package/src/templates/blog/package.json

@@ -4,10 +4,11 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "astro dev",
-    "build": "astro build",
-    "check": "astro check",
-    "preview": "astro preview",
+    "dev": "bun --hot serve.ts",
+    "start": "bun serve.ts",
+    "build": "bun scripts/build.ts",
+    "preview": "bun scripts/preview.ts",
+    "check": "tsc --noEmit",
     "ship": "bun scripts/ship.ts",
     "ship:setup": "bun scripts/ship.ts --setup --static --output-dir dist --build-script build --no-spa",
     "ship:update": "bun scripts/ship.ts --update",
@@ -16,16 +17,14 @@
     "ship:webhook": "bun scripts/ship.ts --webhook"
   },
   "dependencies": {
-    "@astrojs/rss": "4.0.19",
-    "@astrojs/sitemap": "3.7.3",
-    "astro": "7.2.4"
+    "hono": "4.13.3"
   },
   "devDependencies": {
-    "@astrojs/check": "0.9.10",
     "@clack/prompts": "1.7.0",
+    "@types/bun": "1.4.0",
     "typescript": "5.9.2"
   },
   "engines": {
     "bun": ">=1.4.0"
   }
-}
+}

package/src/templates/blog/scripts/build.ts

@@ -0,0 +1,48 @@
+// Pre-renders the blog to static files in dist/: the same Hono app that
+// `bun dev` serves, rendered once. Ship packages this output; nothing here
+// runs in production.
+import { cp, mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import app, { publishedPosts } from "../src/app";
+
+const output = "dist";
+
+async function write(path: string, body: string | ArrayBuffer): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, body instanceof ArrayBuffer ? new Uint8Array(body) : body);
+}
+
+async function responseBody(path: string): Promise<string> {
+  const response = await app.request(path);
+  if (!response.ok) {
+    throw new Error(`cannot build ${path}: HTTP ${response.status}`);
+  }
+  return response.text();
+}
+
+await rm(output, { recursive: true, force: true });
+await cp("public", output, { recursive: true });
+
+const posts = await publishedPosts();
+const htmlRoutes = ["/", ...posts.map((post) => `/posts/${post.slug}`)];
+for (const route of htmlRoutes) {
+  const path = route === "/" ? join(output, "index.html") : join(output, route.slice(1), "index.html");
+  await write(path, await responseBody(route));
+}
+
+const notFound = await app.request("/404");
+if (notFound.status !== 404) {
+  throw new Error(`cannot build /404: HTTP ${notFound.status}`);
+}
+await write(join(output, "404.html"), await notFound.text());
+
+for (const file of ["rss.xml", "llms.txt", "robots.txt", "sitemap.xml"]) {
+  await write(join(output, file), await responseBody(`/${file}`));
+}
+for (const post of posts) {
+  // Markdown alternates: every post is also served as plain markdown so
+  // agents can read the source of the writing (llms.txt links here).
+  await write(join(output, "posts", `${post.slug}.md`), await responseBody(`/posts/${post.slug}.md`));
+}
+
+console.log(`Built ${htmlRoutes.length} HTML routes + feeds in ${output}/`);

package/src/templates/blog/scripts/preview.ts

@@ -0,0 +1,42 @@
+// Local preview of dist/ (run `bun run build` first). Production serving is
+// the pinned static image that bun ship builds; this file never ships.
+import { realpathSync } from "node:fs";
+import { join, normalize } from "node:path";
+
+const ROOT = join(import.meta.dir, "..", "dist");
+function withHeaders(res: Response): Response {
+  res.headers.set("X-Content-Type-Options", "nosniff");
+  res.headers.set("X-Frame-Options", "DENY");
+  res.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
+  return res;
+}
+const server = Bun.serve({
+  port: Number(process.env.PORT) || 9001,
+  async fetch(request) {
+    if (request.method !== "GET" && request.method !== "HEAD") return withHeaders(new Response("Not found", { status: 404 }));
+    let pathname;
+    try {
+      pathname = decodeURIComponent(new URL(request.url).pathname);
+    } catch {
+      return withHeaders(new Response("Bad request", { status: 400 }));
+    }
+    const safe = normalize(pathname).replaceAll("\\", "/");
+    if (safe.includes("..")) return withHeaders(new Response("Not found", { status: 404 }));
+    const candidate = safe.endsWith("/") ? join(ROOT, safe, "index.html") : join(ROOT, safe);
+    if (!candidate.startsWith(ROOT)) return withHeaders(new Response("Not found", { status: 404 }));
+    let resolved;
+    try {
+      resolved = realpathSync(candidate);
+    } catch {
+      resolved = undefined;
+    }
+    // realpath containment: a symlink inside dist/ must not escape it.
+    if (resolved && (resolved === realpathSync(ROOT) || resolved.startsWith(realpathSync(ROOT) + "/"))) {
+      const file = Bun.file(resolved);
+      if (await file.exists()) return withHeaders(new Response(file));
+    }
+    const notFound = Bun.file(join(ROOT, "404.html"));
+    return withHeaders(new Response((await notFound.exists()) ? notFound : "Not found", { status: 404 }));
+  },
+});
+console.log(`Previewing dist/ on http://localhost:${server.port}`);

package/src/templates/blog/serve.ts

@@ -0,0 +1,11 @@
+import app from "./src/app";
+
+const port = Number(process.env.SHIBUMI_PORT ?? process.env.PORT ?? 9001);
+if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+  throw new Error("SHIBUMI_PORT must be an integer from 1 to 65535");
+}
+
+export default {
+  port,
+  fetch: app.fetch,
+};

package/src/templates/blog/src/app.ts

@@ -0,0 +1,418 @@
+// The blog engine: a small Bun + Hono renderer, the same engine that runs
+// shibumistack.dev. Posts are markdown with YAML frontmatter in
+// src/content/blog/; Bun's built-in markdown renderer turns them into HTML.
+// `bun dev` serves this app live; scripts/build.ts pre-renders the very same
+// routes to dist/, so what you build is what you preview and what ships.
+import { Hono } from "hono";
+import { serveStatic } from "hono/bun";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { YAML } from "bun";
+import { SITE } from "./site";
+
+const app = new Hono();
+
+const slugPattern = /^[a-z0-9][a-z0-9-]*$/;
+const urlBase = SITE.url.replace(/\/$/, "");
+
+export type Post = {
+  slug: string;
+  title: string;
+  description: string;
+  date: Date;
+  ogImage?: string;
+  ogImageAlt?: string;
+  draft: boolean;
+  path: string;
+};
+
+const assetVersion = createHash("sha256").update(readFileSync("public/style.css")).digest("hex").slice(0, 12);
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
+async function read(path: string): Promise<string> {
+  return Bun.file(path).text();
+}
+
+function parseFrontmatter(text: string): { frontmatter: Record<string, unknown>; body: string } {
+  if (!text.startsWith("---")) {
+    return { frontmatter: {}, body: text };
+  }
+  const end = text.indexOf("---", 3);
+  if (end === -1) {
+    return { frontmatter: {}, body: text };
+  }
+  return {
+    frontmatter: (YAML.parse(text.slice(3, end).trim()) as Record<string, unknown> | undefined) ?? {},
+    body: text.slice(end + 3).trimStart(),
+  };
+}
+
+// The SEO contract, enforced at build and serve time so a bad post fails
+// loudly instead of shipping silently: a title that fits a tab and a
+// description that fits a search snippet, both feeding the meta tags, RSS,
+// and llms.txt. Carried over from the previous template's content schema.
+function validatePost(slug: string, frontmatter: Record<string, unknown>): void {
+  const title = frontmatter.title;
+  if (typeof title !== "string" || title.length === 0 || title.length > 60) {
+    throw new Error(`posts/${slug}.md: title must be a string from 1 to 60 characters`);
+  }
+  const description = frontmatter.description;
+  if (typeof description !== "string" || description.length < 50 || description.length > 160) {
+    throw new Error(`posts/${slug}.md: description must be 50 to 160 characters`);
+  }
+  if (frontmatter.date === undefined || Number.isNaN(new Date(String(frontmatter.date)).getTime())) {
+    throw new Error(`posts/${slug}.md: date must be a parseable date`);
+  }
+  if (frontmatter.ogImage !== undefined && typeof frontmatter.ogImage !== "string") {
+    throw new Error(`posts/${slug}.md: ogImage must be a path string`);
+  }
+  if (frontmatter.ogImageAlt !== undefined && typeof frontmatter.ogImageAlt !== "string") {
+    throw new Error(`posts/${slug}.md: ogImageAlt must be a string`);
+  }
+}
+
+async function discoverPosts(): Promise<Post[]> {
+  const dir = "src/content/blog";
+  const posts: Post[] = [];
+  try {
+    if (!(await stat(dir)).isDirectory()) return posts;
+  } catch {
+    return posts;
+  }
+
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+
+    const slug = entry.name.slice(0, -3);
+    if (!slugPattern.test(slug)) {
+      throw new Error(`Unsafe file name in ${dir}: ${entry.name}`);
+    }
+
+    const text = await read(`${dir}/${entry.name}`);
+    const { frontmatter } = parseFrontmatter(text);
+    validatePost(slug, frontmatter);
+
+    posts.push({
+      slug,
+      title: String(frontmatter.title),
+      description: String(frontmatter.description),
+      date: new Date(String(frontmatter.date)),
+      ogImage: typeof frontmatter.ogImage === "string" ? frontmatter.ogImage : undefined,
+      ogImageAlt: typeof frontmatter.ogImageAlt === "string" ? frontmatter.ogImageAlt : undefined,
+      // Draft posts build nowhere: no page, no listing, no RSS, no llms.txt.
+      // Flip to false (or remove the line) to publish.
+      draft: frontmatter.draft === true,
+      path: `${dir}/${entry.name}`,
+    });
+  }
+
+  return posts.sort((a, b) => b.date.getTime() - a.date.getTime());
+}
+
+export async function publishedPosts(): Promise<Post[]> {
+  return (await discoverPosts()).filter((post) => !post.draft);
+}
+
+function canonical(path: string): string {
+  return path === "/" ? urlBase : `${urlBase}${path.replace(/\/$/, "")}/`;
+}
+
+function replaceValueTokens(content: string, vars: Record<string, string>): string {
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`{{${key}}}`, escapeHtml(value));
+  }
+  return content;
+}
+
+function assertNoTokens(label: string, content: string): void {
+  const unresolved = content.match(/{{[^}]+}}/);
+  if (unresolved) {
+    throw new Error(`Unresolved token in ${label}: ${unresolved[0]}`);
+  }
+}
+
+function insert(content: string, name: string, value: string): string {
+  return content.replaceAll(`<!-- insert:${name} -->`, value);
+}
+
+function assertNoInserts(content: string): void {
+  const unresolved = content.match(/<!-- insert:[a-z0-9-]+ -->/);
+  if (unresolved) {
+    throw new Error(`Unresolved insert: ${unresolved[0]}`);
+  }
+}
+
+async function renderTokens(label: string, content: string, vars: Record<string, string> = {}): Promise<string> {
+  const rendered = replaceValueTokens(content, vars);
+  assertNoTokens(label, rendered);
+  return rendered;
+}
+
+function isSafeHref(href: string): boolean {
+  return /^https?:\/\//i.test(href) || /^mailto:/i.test(href) || /^tel:/i.test(href) || /^\//.test(href) || /^#/.test(href);
+}
+
+function highlightCode(text: string, language = "text"): string {
+  let code = escapeHtml(text);
+  const stash: string[] = [];
+  const token = (className: string, value: string) => {
+    const key = String.fromCodePoint(0xe000 + stash.length);
+    stash.push(`<span class="syntax-${className}">${value}</span>`);
+    return key;
+  };
+
+  if (["sh", "bash", "shell"].includes(language)) {
+    code = code
+      .replace(/(^|\s)(#[^\n]*)/gm, (_match, lead, value) => `${lead}${token("comment", value)}`)
+      .replace(/(&quot;[^\n]*?&quot;|'[^\n]*?')/g, (value) => token("string", value))
+      .replace(/(^|[;&|]\s*)(bun|shis|ssh|sh|git|gh|curl|cd|systemctl|journalctl|podman|npm|docker|brew|mkdir|sudo)(?=\s|$)/gm, (_match, lead, value) => `${lead}${token("command", value)}`)
+      .replace(/(^|\s)(--?[a-z][a-z0-9-]*)(?=\s|$)/g, (_match, lead, value) => `${lead}${token("option", value)}`);
+  } else if (language === "json") {
+    code = code
+      .replace(/(&quot;[^&\n]*?&quot;)(\s*:)?/g, (_match, value, colon) => token(colon ? "key" : "string", value) + (colon ?? ""))
+      .replace(/\b(true|false|null)\b/g, (value) => token("literal", value))
+      .replace(/\b-?\d+(?:\.\d+)?\b/g, (value) => token("number", value));
+  } else if (["ts", "typescript", "js", "javascript"].includes(language)) {
+    code = code
+      .replace(/(\/\/[^\n]*|\/\*[\s\S]*?\*\/)/g, (value) => token("comment", value))
+      .replace(/(&quot;[^\n]*?&quot;|'[^\n]*?'|`[^\n]*?`)/g, (value) => token("string", value))
+      .replace(/\b(import|export|from|const|let|function|async|await|return|if|else|new|throw|type|interface)\b/g, (value) => token("keyword", value));
+  } else if (["html", "xml"].includes(language)) {
+    code = code
+      .replace(/(&lt;!--[\s\S]*?--&gt;)/g, (value) => token("comment", value))
+      .replace(/(&quot;[^\n]*?&quot;)/g, (value) => token("string", value))
+      .replace(/(&lt;\/?)([a-zA-Z][a-zA-Z0-9-]*)/g, (_match, lead, name) => `${lead}${token("keyword", name)}`)
+      .replace(/([a-zA-Z][a-zA-Z0-9-]*)(=)/g, (_match, attr, eq) => `${token("key", attr)}${eq}`);
+  }
+
+  return code.replace(/[\ue000-\uf8ff]/g, (key) => stash[key.codePointAt(0)! - 0xe000]!);
+}
+
+// Safe-by-default markdown: raw HTML is dropped, links must be http(s),
+// mailto, tel, relative, or fragment, and code gets classed spans.
+function safeMarkdownHtml(markdown: string): string {
+  return Bun.markdown.render(markdown, {
+    html: () => "",
+    heading: (children, attrs: { level: number }) => `<h${attrs.level}>${children}</h${attrs.level}>`,
+    paragraph: (children) => `<p>${children}</p>`,
+    strong: (children) => `<strong>${children}</strong>`,
+    emphasis: (children) => `<em>${children}</em>`,
+    codespan: (text) => `<code>${escapeHtml(text)}</code>`,
+    code: (text, meta?: { language?: string }) => {
+      const lang = meta?.language ? ` language="${meta.language}"` : "";
+      return `<pre><code${lang}>${highlightCode(text, (meta?.language ?? "text").toLowerCase())}</code></pre>`;
+    },
+    link: (children, attrs: { href: string }) => (isSafeHref(attrs.href) ? `<a href="${attrs.href}">${children}</a>` : children),
+    image: (children, attrs: { src: string }) =>
+      isSafeHref(attrs.src) ? `<img src="${attrs.src}" alt="${escapeHtml(children.replace(/<[^>]+>/g, ""))}" loading="lazy">` : "",
+    list: (children, attrs: { ordered: boolean }) => {
+      const tag = attrs.ordered ? "ol" : "ul";
+      return `<${tag}>${children}</${tag}>`;
+    },
+    listItem: (children) => `<li>${children}</li>`,
+    blockquote: (children) => `<blockquote>${children}</blockquote>`,
+  });
+}
+
+function ogImageFor(post?: Post): string {
+  if (post?.ogImage) {
+    return post.ogImage.startsWith("/") ? urlBase + post.ogImage : `${urlBase}/${post.ogImage}`;
+  }
+  return `${urlBase}/og-default.png`;
+}
+
+async function metaHtml(title: string, description: string, path: string, post?: Post): Promise<string> {
+  const url = canonical(path);
+  const image = ogImageFor(post);
+  // og:image dimensions are only declared for the default 1200×630 image;
+  // a custom ogImage can be any size, so we leave its dimensions to the
+  // platform to measure. Image alt comes from the post's ogImageAlt or
+  // falls back to the site name; without a custom image there is no alt.
+  const defaultImage = post === undefined || post.ogImage === undefined;
+  // Alt text for the declared image: the post's ogImageAlt when it has a
+  // custom image, the site name for the known default og image, nothing
+  // when a custom image ships without an alt to describe it.
+  const imageAlt = post?.ogImageAlt ?? (defaultImage ? SITE.name : undefined);
+  const twitter = SITE.twitter.replace(/^@/, "");
+  const tags = [
+    `<meta property="og:type" content="${post ? "article" : "website"}">`,
+    `<meta property="og:url" content="${url}">`,
+    `<meta property="og:title" content="${escapeHtml(title)}">`,
+    `<meta property="og:description" content="${escapeHtml(description)}">`,
+    `<meta property="og:image" content="${image}">`,
+    ...(defaultImage
+      ? [`<meta property="og:image:width" content="1200">`, `<meta property="og:image:height" content="630">`]
+      : []),
+    ...(imageAlt ? [`<meta property="og:image:alt" content="${escapeHtml(imageAlt)}">`] : []),
+    `<meta property="og:locale" content="en_US">`,
+    `<meta property="og:site_name" content="${escapeHtml(SITE.name)}">`,
+    ...(post ? [`<meta property="article:published_time" content="${post.date.toISOString()}">`] : []),
+    `<meta name="twitter:card" content="summary_large_image">`,
+    ...(twitter ? [`<meta name="twitter:site" content="${escapeHtml(twitter)}">`] : []),
+    `<meta name="twitter:url" content="${url}">`,
+    `<meta name="twitter:title" content="${escapeHtml(title)}">`,
+    `<meta name="twitter:description" content="${escapeHtml(description)}">`,
+    `<meta name="twitter:image" content="${image}">`,
+    ...(imageAlt ? [`<meta name="twitter:image:alt" content="${escapeHtml(imageAlt)}">`] : []),
+    ...(post ? [`<link rel="alternate" type="text/markdown" href="/posts/${post.slug}.md">`] : []),
+  ];
+  return tags.join("\n    ");
+}
+
+async function frame(title: string, description: string, path: string, page: string, post?: Post): Promise<string> {
+  let layout = await renderTokens("layout", await read("src/layout.html"), {
+    title,
+    description,
+    author: SITE.author,
+    "site-name": SITE.name,
+    canonical: canonical(path),
+    year: String(new Date().getFullYear()),
+    "asset-version": assetVersion,
+  });
+  layout = insert(layout, "meta", await metaHtml(title, description, path, post));
+  layout = insert(layout, "page-style", "");
+  layout = insert(layout, "page", page);
+  layout = insert(layout, "page-script", "");
+  assertNoInserts(layout);
+  return layout;
+}
+
+async function homeHtml(): Promise<string> {
+  const posts = await publishedPosts();
+  const items = posts
+    .map(
+      (post) =>
+        `<li><a href="/posts/${post.slug}/"><time datetime="${post.date.toISOString().split("T")[0]}">${post.date.toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" })}</time><h3>${escapeHtml(post.title)}</h3><p>${escapeHtml(post.description)}</p></a></li>`,
+    )
+    .join("\n      ");
+
+  let page = await renderTokens("home", await read("src/pages/index.html"), { "site-name": SITE.name });
+  page = insert(page, "posts", items);
+  return frame(SITE.name, SITE.description, "/", page);
+}
+
+async function postHtml(slug: string): Promise<string | undefined> {
+  const post = (await publishedPosts()).find((candidate) => candidate.slug === slug);
+  if (!post) return;
+
+  const { body } = parseFrontmatter(await read(post.path));
+  const dateIso = post.date.toISOString().split("T")[0]!;
+  const dateDisplay = post.date.toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
+
+  // Neutralize any remaining template tokens that arrived in the markdown
+  // itself so a `{{ }}` in a post cannot become markup.
+  const renderedBody = safeMarkdownHtml(body).replaceAll("{{", "&#123;&#123;").replaceAll("}}", "&#125;&#125;");
+
+  let page = await renderTokens("post", await read("src/pages/post.html"), {
+    "site-name": SITE.name,
+    "date-iso": dateIso,
+    date: dateDisplay,
+    title: post.title,
+    description: post.description,
+  });
+  page = insert(page, "body", renderedBody);
+  return frame(post.title, post.description, `/posts/${post.slug}`, page, post);
+}
+
+async function postMarkdown(slug: string): Promise<string | undefined> {
+  const post = (await publishedPosts()).find((candidate) => candidate.slug === slug);
+  if (!post) return;
+  const { body } = parseFrontmatter(await read(post.path));
+  return `# ${post.title}\n\n${post.date.toISOString().slice(0, 10)}\n\n${body.trim()}\n`;
+}
+
+async function notFoundHtml(): Promise<string> {
+  const page = await renderTokens("404", await read("src/pages/404.html"), { "site-name": SITE.name });
+  return frame(`Not found · ${SITE.name}`, SITE.description, "/404", page);
+}
+
+async function rssXml(): Promise<string> {
+  const posts = await publishedPosts();
+  const items = posts
+    .map((post) => {
+      const url = canonical(`/posts/${post.slug}`);
+      return [
+        "  <item>",
+        `    <title>${escapeXml(post.title)}</title>`,
+        `    <link>${url}</link>`,
+        `    <guid>${url}</guid>`,
+        `    <pubDate>${post.date.toUTCString()}</pubDate>`,
+        `    <description>${escapeXml(post.description)}</description>`,
+        "  </item>",
+      ].join("\n");
+    })
+    .join("\n");
+  return ['<?xml version="1.0" encoding="UTF-8"?>', '<rss version="2.0">', "  <channel>", `    <title>${escapeXml(SITE.name)}</title>`, `    <link>${urlBase}/</link>`, `    <description>${escapeXml(SITE.description)}</description>`, "    <language>en</language>", items, "  </channel>", "</rss>", ""].join("\n");
+}
+
+async function llmsTxt(): Promise<string> {
+  const posts = await publishedPosts();
+  return [
+    `# ${SITE.name}`,
+    "",
+    `> ${SITE.description}`,
+    "",
+    "Every post is also available as plain markdown at the .md links below.",
+    "",
+    "## Posts",
+    "",
+    ...posts.map((post) => `- [${post.title}](${urlBase}/posts/${post.slug}.md): ${post.description}`),
+    "",
+  ].join("\n");
+}
+
+async function robotsTxt(): Promise<string> {
+  return `User-agent: *\nAllow: /\n\nSitemap: ${urlBase}/sitemap.xml\n`;
+}
+
+async function sitemapXml(): Promise<string> {
+  const posts = await publishedPosts();
+  const urls = ["/", ...posts.map((post) => `/posts/${post.slug}`)]
+    .map((path) => `  <url><loc>${canonical(path)}</loc></url>`)
+    .join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls}\n</urlset>\n`;
+}
+
+app.get("/", async (c) => c.html(await homeHtml()));
+
+app.get("/posts/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  // Markdown alternates live at the same URL with `.md` appended; the
+  // `:slug` param would otherwise swallow them as an unknown post id.
+  if (slug.endsWith(".md")) {
+    const body = await postMarkdown(slug.slice(0, -3));
+    if (body === undefined) return c.notFound();
+    return c.body(body, 200, { "content-type": "text/plain; charset=utf-8", "content-disposition": "inline" });
+  }
+  const html = await postHtml(slug);
+  if (html) return c.html(html);
+  return c.notFound();
+});
+
+app.get("/rss.xml", async (c) => c.body(await rssXml(), 200, { "content-type": "application/rss+xml; charset=utf-8" }));
+app.get("/llms.txt", async (c) => c.body(await llmsTxt(), 200, { "content-type": "text/plain; charset=utf-8" }));
+app.get("/robots.txt", async (c) => c.body(await robotsTxt(), 200, { "content-type": "text/plain; charset=utf-8" }));
+app.get("/sitemap.xml", async (c) => c.body(await sitemapXml(), 200, { "content-type": "application/xml; charset=utf-8" }));
+
+app.use("/*", serveStatic({ root: "./public" }));
+
+app.notFound(async (c) => c.html(await notFoundHtml(), 404));
+
+export default app;

package/src/templates/blog/src/layout.html

@@ -0,0 +1,25 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="generator" content="Shibumistack.dev v{{generator-version}}">
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#f5f0e4">
+    <meta name="color-scheme" content="light dark">
+    <meta name="robots" content="index, follow, max-image-preview:large">
+    <title>{{title}}</title>
+    <meta name="description" content="{{description}}" />
+    <meta name="author" content="{{author}}" />
+    <link rel="canonical" href="{{canonical}}" />
+    <link rel="stylesheet" href="/style.css?v={{asset-version}}" />
+    <link rel="alternate" type="application/rss+xml" title="{{site-name}}" href="/rss.xml" />
+    <!-- insert:meta -->
+    <!-- insert:page-style -->
+  </head>
+  <body>
+    <!-- insert:page -->
+    <footer>© {{year}} {{author}} · <a href="/rss.xml">RSS</a> · <a href="/llms.txt">llms.txt</a></footer>
+    <!-- insert:page-script -->
+  </body>
+</html>

package/src/templates/blog/src/pages/404.html

@@ -0,0 +1,6 @@
+<main>
+  <article>
+    <h1>Not found.</h1>
+    <p><a href="/">Back to the start.</a></p>
+  </article>
+</main>

package/src/templates/blog/src/pages/index.html

@@ -0,0 +1,11 @@
+<main>
+  <article>
+    <h1 class="home-title">
+      <span class="mark-badge">渋み</span>
+      <span>{{site-name}}</span>
+    </h1>
+    <ul class="posts">
+      <!-- insert:posts -->
+    </ul>
+  </article>
+</main>

package/src/templates/blog/src/pages/post.html

@@ -0,0 +1,15 @@
+<header>
+  <a href="/" class="mark">
+    <span class="mark-badge">渋み</span>
+    <span>{{site-name}}</span>
+  </a>
+</header>
+<main>
+  <article>
+    <p><time datetime="{{date-iso}}">{{date}}</time></p>
+    <h1>{{title}}</h1>
+    <p class="lede">{{description}}</p>
+    <!-- insert:body -->
+    <p class="post-end"><a class="ghost-pill" href="/">← Back to the blog</a></p>
+  </article>
+</main>

package/src/templates/blog/src/site.ts

@@ -1,7 +1,12 @@
 // One place for site identity. Everything (head tags, RSS, llms.txt,
-// footer) reads from here.
+// sitemap, robots) reads from here.
 export const SITE = {
   name: "Quiet notes",
   description: "A blog about building calm, owned software.",
   author: "Your Name",
-};
+  // Set to your handle (without "@") to emit twitter:site, e.g. "quietnotes".
+  twitter: "",
+  // TODO: set your real domain before the first `bun ship`; canonicals,
+  // og:url, RSS links, and the sitemap all derive from it.
+  url: "https://example.com",
+};

package/src/templates/blog/tsconfig.json

@@ -1,5 +1,19 @@
 {
-  "extends": "astro/tsconfigs/strict",
-  "include": [".astro/types.d.ts", "src/**/*"],
-  "exclude": ["dist"]
-}
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "strict": true,
+    "types": [
+      "bun-types"
+    ],
+    "skipLibCheck": true
+  },
+  "include": [
+    "src",
+    "serve.ts",
+    "scripts"
+  ]
+}