livemark 0.20.0 → 0.22.0

package/build/components/SidebarPosts.js

@@ -1,4 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { config } from "livemark:virtual";
 import { Link, useLocation } from "@tanstack/react-router";
 import { Clock, List, Rss, Tag } from "lucide-react";
 import { currentSection, sectionFlatArticles, sortedArticles, } from "../content/article.js";
@@ -36,10 +37,9 @@ export function SidebarPosts() {
                                                                 _splat: post.path.replace(/^\/|\/$/g, ""),
                                                             } }), children: _jsx("span", { children: post.title }) }) }, post.path));
                                             }) })
-                                    ] }), _jsx(SidebarMenuItem, { children: _jsxs(SidebarMenuButton, { className: "opacity-75", children: [
+                                    ] }), config.site && (_jsx(SidebarMenuItem, { children: _jsxs(SidebarMenuButton, { className: "opacity-75", render: _jsx("a", { href: `/${sectionPath}/rss.xml` }), children: [
                                             _jsx(Rss, { className: "size-4" }), _jsx("span", { children: "RSS Feed" })
-                                        ] }) })
-                            ] }) })
+                                        ] }) }))] }) })
                 ] }), tags.length > 0 && (_jsxs(SidebarGroup, { children: [
                     _jsx(SidebarGroupLabel, { className: "uppercase font-mono text-xs tracking-widest", children: "Tags" }), _jsx(SidebarGroupContent, { children: _jsx(SidebarMenu, { children: tags.map(tag => {
                                 const tagPath = `${sectionPath}/tags/${tag}`;
@@ -50,4 +50,4 @@ export function SidebarPosts() {
                             }) }) })
                 ] }))] }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SidebarPosts.js","sourceRoot":"","sources":["../../source/components/SidebarPosts.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,GACf,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAyB,CAAA;AAEhC,kFAAkF;AAClF,MAAM,UAAU,YAAY;IAC1B,MAAM,QAAQ,GAAG,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAA;IAEzD,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,GAAG,CAAC,CAAA;IACvE,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;IAC3E,MAAM,KAAK,GAAG,IAAI;SACf,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;SAChD,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAA;IAC/B,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAErC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAA;IACjC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;YAClC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAClB,CAAC;IACH,CAAC;IACD,MAAM,IAAI,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,EAAE,CAAA;IAEhC,MAAM,UAAU,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,GAAG,CAAA;IAC1D,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAA;IAC/D,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,IAAI,QAAQ,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;IAEzE,OAAO,CACL;YACE,MAAC,YAAY;oBACX,KAAC,iBAAiB,IAAC,SAAS,EAAC,6CAA6C,sBAEtD,EACpB,KAAC,mBAAmB,cAClB,MAAC,WAAW;gCACV,KAAC,eAAe,cACd,MAAC,iBAAiB,IAChB,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,EACtC,MAAM,EAAE,KAAC,IAAI,IAAC,EAAE,EAAC,IAAI,EAAC,MAAM,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,GAAI;4CAEzD,KAAC,IAAI,IAAC,SAAS,EAAC,QAAQ,GAAG,EAC3B,uCAAsB;4CACJ,GACJ,EAClB,MAAC,eAAe;wCACd,MAAC,iBAAiB,IAAC,SAAS,EAAC,YAAY;gDACvC,KAAC,KAAK,IAAC,SAAS,EAAC,QAAQ,GAAG,EAC5B,0CAAyB;gDACP,EACpB,KAAC,cAAc,cACZ,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gDACtB,MAAM,MAAM,GAAG,UAAU,KAAK,IAAI,CAAC,IAAI,CAAA;gDACvC,OAAO,CACL,KAAC,kBAAkB,cACjB,KAAC,oBAAoB,IACnB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,EACrC,MAAM,EACJ,KAAC,IAAI,IACH,EAAE,EAAC,IAAI,EACP,MAAM,EAAE;gEACN,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC;6DAC1C,GACD,YAGJ,yBAAO,IAAI,CAAC,KAAK,GAAQ,GACJ,IAdA,IAAI,CAAC,IAAI,CAeb,CACtB,CAAA;4CACH,CAAC,CAAC,GACa;wCACD,EAClB,KAAC,eAAe,cACd,MAAC,iBAAiB,IAAC,SAAS,EAAC,YAAY;4CACvC,KAAC,GAAG,IAAC,SAAS,EAAC,QAAQ,GAAG,EAC1B,sCAAqB;4CACH,GACJ;gCACN,GACM;oBACT,EAEd,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAClB,MAAC,YAAY;oBACX,KAAC,iBAAiB,IAAC,SAAS,EAAC,6CAA6C,qBAEtD,EACpB,KAAC,mBAAmB,cAClB,KAAC,WAAW,cACT,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gCACd,MAAM,OAAO,GAAG,GAAG,WAAW,SAAS,GAAG,EAAE,CAAA;gCAC5C,MAAM,SAAS,GAAG,UAAU,KAAK,IAAI,OAAO,GAAG,CAAA;gCAC/C,OAAO,CACL,KAAC,eAAe,cACd,MAAC,iBAAiB,IAChB,QAAQ,EAAE,SAAS,EACnB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,EACxC,MAAM,EAAE,KAAC,IAAI,IAAC,EAAE,EAAC,IAAI,EAAC,MAAM,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAI;4CAErD,KAAC,GAAG,IAAC,SAAS,EAAC,UAAU,GAAG,EAC5B,yBAAO,GAAG,GAAQ;4CACA,IARA,GAAG,CASP,CACnB,CAAA;4BACH,CAAC,CAAC,GACU,GACM;oBACT,CAChB,IACA,CACJ,CAAA;AACH,CAAC","sourcesContent":["import { Link, useLocation } from \"@tanstack/react-router\"\nimport { Clock, List, Rss, Tag } from \"lucide-react\"\nimport {\n  currentSection,\n  sectionFlatArticles,\n  sortedArticles,\n} from \"../content/article.ts\"\nimport {\n  SidebarGroup,\n  SidebarGroupContent,\n  SidebarGroupLabel,\n  SidebarMenu,\n  SidebarMenuButton,\n  SidebarMenuItem,\n  SidebarMenuSub,\n  SidebarMenuSubButton,\n  SidebarMenuSubItem,\n} from \"../elements/sidebar.tsx\"\n\n/** Blog body slot for the Sidebar shell: All Posts / Recent Posts / RSS / Tags */\nexport function SidebarPosts() {\n  const pathname = useLocation({ select: l => l.pathname })\n\n  const section = currentSection(`/${pathname.replace(/^\\/|\\/$/g, \"\")}/`)\n  const flat = section ? (sectionFlatArticles.get(section.prefix) ?? []) : []\n  const posts = flat\n    .map(p => sortedArticles.find(a => a.path === p))\n    .filter(a => a !== undefined)\n  const recentPosts = posts.slice(0, 5)\n\n  const allTags = new Set<string>()\n  for (const post of posts) {\n    for (const tag of post.tags ?? []) {\n      allTags.add(tag)\n    }\n  }\n  const tags = [...allTags].sort()\n\n  const normalized = `/${pathname.replace(/^\\/|\\/$/g, \"\")}/`\n  const isIndex = section ? normalized === section.prefix : false\n  const sectionPath = (section?.prefix ?? \"/blog/\").replace(/^\\/|\\/$/g, \"\")\n\n  return (\n    <>\n      <SidebarGroup>\n        <SidebarGroupLabel className=\"uppercase font-mono text-xs tracking-widest\">\n          Posts\n        </SidebarGroupLabel>\n        <SidebarGroupContent>\n          <SidebarMenu>\n            <SidebarMenuItem>\n              <SidebarMenuButton\n                isActive={isIndex}\n                className={isIndex ? \"\" : \"opacity-75\"}\n                render={<Link to=\"/$\" params={{ _splat: sectionPath }} />}\n              >\n                <List className=\"size-4\" />\n                <span>All Posts</span>\n              </SidebarMenuButton>\n            </SidebarMenuItem>\n            <SidebarMenuItem>\n              <SidebarMenuButton className=\"opacity-75\">\n                <Clock className=\"size-4\" />\n                <span>Recent Posts</span>\n              </SidebarMenuButton>\n              <SidebarMenuSub>\n                {recentPosts.map(post => {\n                  const active = normalized === post.path\n                  return (\n                    <SidebarMenuSubItem key={post.path}>\n                      <SidebarMenuSubButton\n                        isActive={active}\n                        className={active ? \"\" : \"opacity-75\"}\n                        render={\n                          <Link\n                            to=\"/$\"\n                            params={{\n                              _splat: post.path.replace(/^\\/|\\/$/g, \"\"),\n                            }}\n                          />\n                        }\n                      >\n                        <span>{post.title}</span>\n                      </SidebarMenuSubButton>\n                    </SidebarMenuSubItem>\n                  )\n                })}\n              </SidebarMenuSub>\n            </SidebarMenuItem>\n            <SidebarMenuItem>\n              <SidebarMenuButton className=\"opacity-75\">\n                <Rss className=\"size-4\" />\n                <span>RSS Feed</span>\n              </SidebarMenuButton>\n            </SidebarMenuItem>\n          </SidebarMenu>\n        </SidebarGroupContent>\n      </SidebarGroup>\n\n      {tags.length > 0 && (\n        <SidebarGroup>\n          <SidebarGroupLabel className=\"uppercase font-mono text-xs tracking-widest\">\n            Tags\n          </SidebarGroupLabel>\n          <SidebarGroupContent>\n            <SidebarMenu>\n              {tags.map(tag => {\n                const tagPath = `${sectionPath}/tags/${tag}`\n                const tagActive = normalized === `/${tagPath}/`\n                return (\n                  <SidebarMenuItem key={tag}>\n                    <SidebarMenuButton\n                      isActive={tagActive}\n                      className={tagActive ? \"\" : \"opacity-75\"}\n                      render={<Link to=\"/$\" params={{ _splat: tagPath }} />}\n                    >\n                      <Tag className=\"size-3.5\" />\n                      <span>{tag}</span>\n                    </SidebarMenuButton>\n                  </SidebarMenuItem>\n                )\n              })}\n            </SidebarMenu>\n          </SidebarGroupContent>\n        </SidebarGroup>\n      )}\n    </>\n  )\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SidebarPosts.js","sourceRoot":"","sources":["../../source/components/SidebarPosts.tsx"],"names":[],"mappings":"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","sourcesContent":["import { config } from \"livemark:virtual\"\nimport { Link, useLocation } from \"@tanstack/react-router\"\nimport { Clock, List, Rss, Tag } from \"lucide-react\"\nimport {\n  currentSection,\n  sectionFlatArticles,\n  sortedArticles,\n} from \"../content/article.ts\"\nimport {\n  SidebarGroup,\n  SidebarGroupContent,\n  SidebarGroupLabel,\n  SidebarMenu,\n  SidebarMenuButton,\n  SidebarMenuItem,\n  SidebarMenuSub,\n  SidebarMenuSubButton,\n  SidebarMenuSubItem,\n} from \"../elements/sidebar.tsx\"\n\n/** Blog body slot for the Sidebar shell: All Posts / Recent Posts / RSS / Tags */\nexport function SidebarPosts() {\n  const pathname = useLocation({ select: l => l.pathname })\n\n  const section = currentSection(`/${pathname.replace(/^\\/|\\/$/g, \"\")}/`)\n  const flat = section ? (sectionFlatArticles.get(section.prefix) ?? []) : []\n  const posts = flat\n    .map(p => sortedArticles.find(a => a.path === p))\n    .filter(a => a !== undefined)\n  const recentPosts = posts.slice(0, 5)\n\n  const allTags = new Set<string>()\n  for (const post of posts) {\n    for (const tag of post.tags ?? []) {\n      allTags.add(tag)\n    }\n  }\n  const tags = [...allTags].sort()\n\n  const normalized = `/${pathname.replace(/^\\/|\\/$/g, \"\")}/`\n  const isIndex = section ? normalized === section.prefix : false\n  const sectionPath = (section?.prefix ?? \"/blog/\").replace(/^\\/|\\/$/g, \"\")\n\n  return (\n    <>\n      <SidebarGroup>\n        <SidebarGroupLabel className=\"uppercase font-mono text-xs tracking-widest\">\n          Posts\n        </SidebarGroupLabel>\n        <SidebarGroupContent>\n          <SidebarMenu>\n            <SidebarMenuItem>\n              <SidebarMenuButton\n                isActive={isIndex}\n                className={isIndex ? \"\" : \"opacity-75\"}\n                render={<Link to=\"/$\" params={{ _splat: sectionPath }} />}\n              >\n                <List className=\"size-4\" />\n                <span>All Posts</span>\n              </SidebarMenuButton>\n            </SidebarMenuItem>\n            <SidebarMenuItem>\n              <SidebarMenuButton className=\"opacity-75\">\n                <Clock className=\"size-4\" />\n                <span>Recent Posts</span>\n              </SidebarMenuButton>\n              <SidebarMenuSub>\n                {recentPosts.map(post => {\n                  const active = normalized === post.path\n                  return (\n                    <SidebarMenuSubItem key={post.path}>\n                      <SidebarMenuSubButton\n                        isActive={active}\n                        className={active ? \"\" : \"opacity-75\"}\n                        render={\n                          <Link\n                            to=\"/$\"\n                            params={{\n                              _splat: post.path.replace(/^\\/|\\/$/g, \"\"),\n                            }}\n                          />\n                        }\n                      >\n                        <span>{post.title}</span>\n                      </SidebarMenuSubButton>\n                    </SidebarMenuSubItem>\n                  )\n                })}\n              </SidebarMenuSub>\n            </SidebarMenuItem>\n            {config.site && (\n              <SidebarMenuItem>\n                <SidebarMenuButton\n                  className=\"opacity-75\"\n                  render={<a href={`/${sectionPath}/rss.xml`} />}\n                >\n                  <Rss className=\"size-4\" />\n                  <span>RSS Feed</span>\n                </SidebarMenuButton>\n              </SidebarMenuItem>\n            )}\n          </SidebarMenu>\n        </SidebarGroupContent>\n      </SidebarGroup>\n\n      {tags.length > 0 && (\n        <SidebarGroup>\n          <SidebarGroupLabel className=\"uppercase font-mono text-xs tracking-widest\">\n            Tags\n          </SidebarGroupLabel>\n          <SidebarGroupContent>\n            <SidebarMenu>\n              {tags.map(tag => {\n                const tagPath = `${sectionPath}/tags/${tag}`\n                const tagActive = normalized === `/${tagPath}/`\n                return (\n                  <SidebarMenuItem key={tag}>\n                    <SidebarMenuButton\n                      isActive={tagActive}\n                      className={tagActive ? \"\" : \"opacity-75\"}\n                      render={<Link to=\"/$\" params={{ _splat: tagPath }} />}\n                    >\n                      <Tag className=\"size-3.5\" />\n                      <span>{tag}</span>\n                    </SidebarMenuButton>\n                  </SidebarMenuItem>\n                )\n              })}\n            </SidebarMenu>\n          </SidebarGroupContent>\n        </SidebarGroup>\n      )}\n    </>\n  )\n}\n"]}

package/build/helpers/rss.d.ts

@@ -0,0 +1,21 @@
+export interface RssItem {
+    title: string;
+    link: string;
+    guid: string;
+    description?: string;
+    pubDate?: string;
+    author?: string | string[];
+    categories?: string[];
+}
+export interface RssFeed {
+    title: string;
+    description: string;
+    link: string;
+    feedLink: string;
+    items: RssItem[];
+}
+/** Render an RSS 2.0 channel as a serialized XML document. Pure — all I/O,
+ *  URL composition, and item-count limits live in the caller. `pubDate` is
+ *  accepted as an ISO string (article frontmatter shape) and converted to
+ *  RFC 822 here, which is what readers like NetNewsWire and Feedly parse. */
+export declare function renderRssFeed(feed: RssFeed): string;

package/build/helpers/rss.js

@@ -0,0 +1,56 @@
+/** Render an RSS 2.0 channel as a serialized XML document. Pure — all I/O,
+ *  URL composition, and item-count limits live in the caller. `pubDate` is
+ *  accepted as an ISO string (article frontmatter shape) and converted to
+ *  RFC 822 here, which is what readers like NetNewsWire and Feedly parse. */
+export function renderRssFeed(feed) {
+    const lines = [];
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+    lines.push('<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">');
+    lines.push("  <channel>");
+    lines.push(`    <title>${escapeXml(feed.title)}</title>`);
+    lines.push(`    <link>${escapeXml(feed.link)}</link>`);
+    lines.push(`    <description>${escapeXml(feed.description)}</description>`);
+    lines.push(`    <atom:link href="${escapeXml(feed.feedLink)}" rel="self" type="application/rss+xml" />`);
+    for (const item of feed.items) {
+        lines.push("    <item>");
+        lines.push(`      <title>${escapeXml(item.title)}</title>`);
+        lines.push(`      <link>${escapeXml(item.link)}</link>`);
+        lines.push(`      <guid isPermaLink="true">${escapeXml(item.guid)}</guid>`);
+        if (item.description) {
+            lines.push(`      <description>${escapeXml(item.description)}</description>`);
+        }
+        if (item.pubDate) {
+            lines.push(`      <pubDate>${escapeXml(toRfc822(item.pubDate))}</pubDate>`);
+        }
+        if (item.author) {
+            const author = Array.isArray(item.author)
+                ? item.author.join(", ")
+                : item.author;
+            lines.push(`      <author>${escapeXml(author)}</author>`);
+        }
+        if (item.categories) {
+            for (const category of item.categories) {
+                lines.push(`      <category>${escapeXml(category)}</category>`);
+            }
+        }
+        lines.push("    </item>");
+    }
+    lines.push("  </channel>");
+    lines.push("</rss>");
+    return `${lines.join("\n")}\n`;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function toRfc822(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return iso;
+    return date.toUTCString();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/rss.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/helpers/rss.unit.js

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vite-plus/test";
+import { renderRssFeed } from "./rss.js";
+describe("renderRssFeed", () => {
+    it("renders a minimal channel with no items", () => {
+        const xml = renderRssFeed({
+            title: "Blog",
+            description: "Latest posts",
+            link: "https://example.com/blog/",
+            feedLink: "https://example.com/blog/rss.xml",
+            items: [],
+        });
+        expect(xml).toBe(`<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>Blog</title>
+    <link>https://example.com/blog/</link>
+    <description>Latest posts</description>
+    <atom:link href="https://example.com/blog/rss.xml" rel="self" type="application/rss+xml" />
+  </channel>
+</rss>
+`);
+    });
+    it("renders an item with all optional fields", () => {
+        const xml = renderRssFeed({
+            title: "Blog",
+            description: "Latest posts",
+            link: "https://example.com/blog/",
+            feedLink: "https://example.com/blog/rss.xml",
+            items: [
+                {
+                    title: "Hello",
+                    link: "https://example.com/blog/hello/",
+                    guid: "https://example.com/blog/hello/",
+                    description: "First post",
+                    pubDate: "2026-05-16T00:00:00Z",
+                    author: "Jane",
+                    categories: ["news"],
+                },
+            ],
+        });
+        expect(xml).toContain("<title>Hello</title>");
+        expect(xml).toContain("<link>https://example.com/blog/hello/</link>");
+        expect(xml).toContain('<guid isPermaLink="true">https://example.com/blog/hello/</guid>');
+        expect(xml).toContain("<description>First post</description>");
+        expect(xml).toContain("<pubDate>Sat, 16 May 2026 00:00:00 GMT</pubDate>");
+        expect(xml).toContain("<author>Jane</author>");
+        expect(xml).toContain("<category>news</category>");
+    });
+    it("joins array authors with a comma", () => {
+        const xml = renderRssFeed({
+            title: "Blog",
+            description: "",
+            link: "https://example.com/blog/",
+            feedLink: "https://example.com/blog/rss.xml",
+            items: [
+                {
+                    title: "x",
+                    link: "https://example.com/blog/x/",
+                    guid: "https://example.com/blog/x/",
+                    author: ["Alice", "Bob"],
+                },
+            ],
+        });
+        expect(xml).toContain("<author>Alice, Bob</author>");
+    });
+    it("emits one <category> per tag", () => {
+        const xml = renderRssFeed({
+            title: "Blog",
+            description: "",
+            link: "https://example.com/blog/",
+            feedLink: "https://example.com/blog/rss.xml",
+            items: [
+                {
+                    title: "x",
+                    link: "https://example.com/blog/x/",
+                    guid: "https://example.com/blog/x/",
+                    categories: ["a", "b", "c"],
+                },
+            ],
+        });
+        expect(xml).toContain("<category>a</category>");
+        expect(xml).toContain("<category>b</category>");
+        expect(xml).toContain("<category>c</category>");
+    });
+    it("escapes XML metacharacters in text content", () => {
+        const xml = renderRssFeed({
+            title: 'Title & "quoted" <tag>',
+            description: "A & B",
+            link: "https://example.com/blog/",
+            feedLink: "https://example.com/blog/rss.xml",
+            items: [
+                {
+                    title: "1 < 2 & 3 > 0",
+                    link: "https://example.com/blog/x/",
+                    guid: "https://example.com/blog/x/",
+                    description: "It's fine",
+                },
+            ],
+        });
+        expect(xml).toContain("<title>Title &amp; &quot;quoted&quot; &lt;tag&gt;</title>");
+        expect(xml).toContain("<description>A &amp; B</description>");
+        expect(xml).toContain("<title>1 &lt; 2 &amp; 3 &gt; 0</title>");
+        expect(xml).toContain("<description>It&apos;s fine</description>");
+    });
+    it("leaves an unparsable pubDate unchanged", () => {
+        const xml = renderRssFeed({
+            title: "Blog",
+            description: "",
+            link: "https://example.com/blog/",
+            feedLink: "https://example.com/blog/rss.xml",
+            items: [
+                {
+                    title: "x",
+                    link: "https://example.com/blog/x/",
+                    guid: "https://example.com/blog/x/",
+                    pubDate: "not-a-date",
+                },
+            ],
+        });
+        expect(xml).toContain("<pubDate>not-a-date</pubDate>");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rss.unit.js","sourceRoot":"","sources":["../../source/helpers/rss.unit.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vite-plus/test\"\nimport { renderRssFeed } from \"./rss.ts\"\n\ndescribe(\"renderRssFeed\", () => {\n  it(\"renders a minimal channel with no items\", () => {\n    const xml = renderRssFeed({\n      title: \"Blog\",\n      description: \"Latest posts\",\n      link: \"https://example.com/blog/\",\n      feedLink: \"https://example.com/blog/rss.xml\",\n      items: [],\n    })\n    expect(xml).toBe(\n      `<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rss version=\"2.0\" xmlns:atom=\"http://www.w3.org/2005/Atom\">\n  <channel>\n    <title>Blog</title>\n    <link>https://example.com/blog/</link>\n    <description>Latest posts</description>\n    <atom:link href=\"https://example.com/blog/rss.xml\" rel=\"self\" type=\"application/rss+xml\" />\n  </channel>\n</rss>\n`,\n    )\n  })\n\n  it(\"renders an item with all optional fields\", () => {\n    const xml = renderRssFeed({\n      title: \"Blog\",\n      description: \"Latest posts\",\n      link: \"https://example.com/blog/\",\n      feedLink: \"https://example.com/blog/rss.xml\",\n      items: [\n        {\n          title: \"Hello\",\n          link: \"https://example.com/blog/hello/\",\n          guid: \"https://example.com/blog/hello/\",\n          description: \"First post\",\n          pubDate: \"2026-05-16T00:00:00Z\",\n          author: \"Jane\",\n          categories: [\"news\"],\n        },\n      ],\n    })\n    expect(xml).toContain(\"<title>Hello</title>\")\n    expect(xml).toContain(\"<link>https://example.com/blog/hello/</link>\")\n    expect(xml).toContain(\n      '<guid isPermaLink=\"true\">https://example.com/blog/hello/</guid>',\n    )\n    expect(xml).toContain(\"<description>First post</description>\")\n    expect(xml).toContain(\"<pubDate>Sat, 16 May 2026 00:00:00 GMT</pubDate>\")\n    expect(xml).toContain(\"<author>Jane</author>\")\n    expect(xml).toContain(\"<category>news</category>\")\n  })\n\n  it(\"joins array authors with a comma\", () => {\n    const xml = renderRssFeed({\n      title: \"Blog\",\n      description: \"\",\n      link: \"https://example.com/blog/\",\n      feedLink: \"https://example.com/blog/rss.xml\",\n      items: [\n        {\n          title: \"x\",\n          link: \"https://example.com/blog/x/\",\n          guid: \"https://example.com/blog/x/\",\n          author: [\"Alice\", \"Bob\"],\n        },\n      ],\n    })\n    expect(xml).toContain(\"<author>Alice, Bob</author>\")\n  })\n\n  it(\"emits one <category> per tag\", () => {\n    const xml = renderRssFeed({\n      title: \"Blog\",\n      description: \"\",\n      link: \"https://example.com/blog/\",\n      feedLink: \"https://example.com/blog/rss.xml\",\n      items: [\n        {\n          title: \"x\",\n          link: \"https://example.com/blog/x/\",\n          guid: \"https://example.com/blog/x/\",\n          categories: [\"a\", \"b\", \"c\"],\n        },\n      ],\n    })\n    expect(xml).toContain(\"<category>a</category>\")\n    expect(xml).toContain(\"<category>b</category>\")\n    expect(xml).toContain(\"<category>c</category>\")\n  })\n\n  it(\"escapes XML metacharacters in text content\", () => {\n    const xml = renderRssFeed({\n      title: 'Title & \"quoted\" <tag>',\n      description: \"A & B\",\n      link: \"https://example.com/blog/\",\n      feedLink: \"https://example.com/blog/rss.xml\",\n      items: [\n        {\n          title: \"1 < 2 & 3 > 0\",\n          link: \"https://example.com/blog/x/\",\n          guid: \"https://example.com/blog/x/\",\n          description: \"It's fine\",\n        },\n      ],\n    })\n    expect(xml).toContain(\n      \"<title>Title &amp; &quot;quoted&quot; &lt;tag&gt;</title>\",\n    )\n    expect(xml).toContain(\"<description>A &amp; B</description>\")\n    expect(xml).toContain(\"<title>1 &lt; 2 &amp; 3 &gt; 0</title>\")\n    expect(xml).toContain(\"<description>It&apos;s fine</description>\")\n  })\n\n  it(\"leaves an unparsable pubDate unchanged\", () => {\n    const xml = renderRssFeed({\n      title: \"Blog\",\n      description: \"\",\n      link: \"https://example.com/blog/\",\n      feedLink: \"https://example.com/blog/rss.xml\",\n      items: [\n        {\n          title: \"x\",\n          link: \"https://example.com/blog/x/\",\n          guid: \"https://example.com/blog/x/\",\n          pubDate: \"not-a-date\",\n        },\n      ],\n    })\n    expect(xml).toContain(\"<pubDate>not-a-date</pubDate>\")\n  })\n})\n"]}

package/build/plugins/vite-robots.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin } from "vite";
+import type { Config } from "../models/config.ts";
+export interface RobotsOptions {
+    config: Config;
+}
+/** Emit a default `robots.txt` into the client build output, with a
+ *  `Sitemap:` line pointing at the TanStack-Start-generated `sitemap.xml`
+ *  when {@link Config.site} is set. Skipped when the consumer ships
+ *  their own `.livemark/public/robots.txt` so the standard publicDir
+ *  overlay wins — Vite copies the publicDir before writeBundle, so
+ *  unconditional emitFile would silently overwrite the override. */
+export declare function robots(opts: RobotsOptions): Plugin;
+/** Render the body of a permissive default `robots.txt`. A `Sitemap:`
+ *  line is appended only when `site` is set, because the directive
+ *  requires a fully-qualified URL; `base` is included so the URL matches
+ *  where the build (and the `sitemap.xml` inside it) is actually mounted. */
+export declare function renderRobots(config: Pick<Config, "site" | "base">): string;

package/build/plugins/vite-robots.js

@@ -0,0 +1,40 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/** Emit a default `robots.txt` into the client build output, with a
+ *  `Sitemap:` line pointing at the TanStack-Start-generated `sitemap.xml`
+ *  when {@link Config.site} is set. Skipped when the consumer ships
+ *  their own `.livemark/public/robots.txt` so the standard publicDir
+ *  overlay wins — Vite copies the publicDir before writeBundle, so
+ *  unconditional emitFile would silently overwrite the override. */
+export function robots(opts) {
+    const overrideFile = join(opts.config.root, ".livemark", "public", "robots.txt");
+    return {
+        name: "livemark:robots",
+        applyToEnvironment(env) {
+            return env.name === "client";
+        },
+        generateBundle() {
+            if (existsSync(overrideFile))
+                return;
+            this.emitFile({
+                type: "asset",
+                fileName: "robots.txt",
+                source: renderRobots(opts.config),
+            });
+        },
+    };
+}
+/** Render the body of a permissive default `robots.txt`. A `Sitemap:`
+ *  line is appended only when `site` is set, because the directive
+ *  requires a fully-qualified URL; `base` is included so the URL matches
+ *  where the build (and the `sitemap.xml` inside it) is actually mounted. */
+export function renderRobots(config) {
+    const lines = ["User-agent: *", "Allow: /"];
+    if (config.site) {
+        const host = config.site.replace(/\/+$/, "");
+        const base = config.base ?? "";
+        lines.push("", `Sitemap: ${host}${base}/sitemap.xml`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/vite-robots.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/plugins/vite-robots.unit.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vite-plus/test";
+import { renderRobots } from "./vite-robots.js";
+describe("renderRobots", () => {
+    it("emits an allow-all body when site is not set", () => {
+        expect(renderRobots({})).toBe("User-agent: *\nAllow: /\n");
+    });
+    it("appends a Sitemap line when site is set", () => {
+        expect(renderRobots({ site: "https://livemark.dev" })).toBe("User-agent: *\nAllow: /\n\nSitemap: https://livemark.dev/sitemap.xml\n");
+    });
+    it("strips a trailing slash from site before composing the URL", () => {
+        expect(renderRobots({ site: "https://livemark.dev/" })).toBe("User-agent: *\nAllow: /\n\nSitemap: https://livemark.dev/sitemap.xml\n");
+    });
+    it("includes the base path so the URL matches the build mount", () => {
+        expect(renderRobots({ site: "https://user.github.io", base: "/repo" })).toBe("User-agent: *\nAllow: /\n\nSitemap: https://user.github.io/repo/sitemap.xml\n");
+    });
+    it("ignores base when site is not set", () => {
+        expect(renderRobots({ base: "/repo" })).toBe("User-agent: *\nAllow: /\n");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/routeTree.gen.d.ts

@@ -1,32 +1,38 @@
 import { Route as rootRouteImport } from './routes/__root';
 import { Route as splatRouteImport } from './routes/$';
+import { Route as SectionRssDotxmlRouteImport } from './routes/$section.rss[.]xml';
 import { Route as IndexRouteImport } from './../.livemark/routes/index';
 declare const splatRoute: any;
+declare const SectionRssDotxmlRoute: any;
 declare const IndexRoute: any;
 export interface FileRoutesByFullPath {
     '/': typeof IndexRoute;
     '/$': typeof splatRoute;
+    '/$section/rss.xml': typeof SectionRssDotxmlRoute;
 }
 export interface FileRoutesByTo {
     '/': typeof IndexRoute;
     '/$': typeof splatRoute;
+    '/$section/rss.xml': typeof SectionRssDotxmlRoute;
 }
 export interface FileRoutesById {
     __root__: typeof rootRouteImport;
     '/': typeof IndexRoute;
     '/$': typeof splatRoute;
+    '/$section/rss.xml': typeof SectionRssDotxmlRoute;
 }
 export interface FileRouteTypes {
     fileRoutesByFullPath: FileRoutesByFullPath;
-    fullPaths: '/' | '/$';
+    fullPaths: '/' | '/$' | '/$section/rss.xml';
     fileRoutesByTo: FileRoutesByTo;
-    to: '/' | '/$';
-    id: '__root__' | '/' | '/$';
+    to: '/' | '/$' | '/$section/rss.xml';
+    id: '__root__' | '/' | '/$' | '/$section/rss.xml';
     fileRoutesById: FileRoutesById;
 }
 export interface RootRouteChildren {
     IndexRoute: typeof IndexRoute;
     splatRoute: typeof splatRoute;
+    SectionRssDotxmlRoute: typeof SectionRssDotxmlRoute;
 }
 declare module '@tanstack/react-router' {
     interface FileRoutesByPath {
@@ -37,6 +43,13 @@ declare module '@tanstack/react-router' {
             preLoaderRoute: typeof splatRouteImport;
             parentRoute: typeof rootRouteImport;
         };
+        '/$section/rss.xml': {
+            id: '/$section/rss.xml';
+            path: '/$section/rss.xml';
+            fullPath: '/$section/rss.xml';
+            preLoaderRoute: typeof SectionRssDotxmlRouteImport;
+            parentRoute: typeof rootRouteImport;
+        };
         '/': {
             id: '/';
             path: '/';

package/build/routeTree.gen.js

@@ -6,12 +6,18 @@
 // Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
 import { Route as rootRouteImport } from './routes/__root';
 import { Route as splatRouteImport } from './routes/$';
+import { Route as SectionRssDotxmlRouteImport } from './routes/$section.rss[.]xml';
 import { Route as IndexRouteImport } from './../.livemark/routes/index';
 const splatRoute = splatRouteImport.update({
     id: '/$',
     path: '/$',
     getParentRoute: () => rootRouteImport,
 });
+const SectionRssDotxmlRoute = SectionRssDotxmlRouteImport.update({
+    id: '/$section/rss.xml',
+    path: '/$section/rss.xml',
+    getParentRoute: () => rootRouteImport,
+});
 const IndexRoute = IndexRouteImport.update({
     id: '/',
     path: '/',
@@ -20,8 +26,9 @@ const IndexRoute = IndexRouteImport.update({
 const rootRouteChildren = {
     IndexRoute: IndexRoute,
     splatRoute: splatRoute,
+    SectionRssDotxmlRoute: SectionRssDotxmlRoute,
 };
 export const routeTree = rootRouteImport
     ._addFileChildren(rootRouteChildren)
     ._addFileTypes();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVUcmVlLmdlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NvdXJjZS9yb3V0ZVRyZWUuZ2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFvQjtBQUVwQixjQUFjO0FBRWQscUNBQXFDO0FBRXJDLDREQUE0RDtBQUM1RCwwRUFBMEU7QUFDMUUsa0lBQWtJO0FBRWxJLE9BQU8sRUFBRSxLQUFLLElBQUksZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDMUQsT0FBTyxFQUFFLEtBQUssSUFBSSxnQkFBZ0IsRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUN0RCxPQUFPLEVBQUUsS0FBSyxJQUFJLGdCQUFnQixFQUFFLE1BQU0sNkJBQTZCLENBQUE7QUFFdkUsTUFBTSxVQUFVLEdBQUcsZ0JBQWdCLENBQUMsTUFBTSxDQUFDO0lBQ3pDLEVBQUUsRUFBRSxJQUFJO0lBQ1IsSUFBSSxFQUFFLElBQUk7SUFDVixjQUFjLEVBQUUsR0FBRyxFQUFFLENBQUMsZUFBZTtDQUMvQixDQUFDLENBQUE7QUFDVCxNQUFNLFVBQVUsR0FBRyxnQkFBZ0IsQ0FBQyxNQUFNLENBQUM7SUFDekMsRUFBRSxFQUFFLEdBQUc7SUFDUCxJQUFJLEVBQUUsR0FBRztJQUNULGNBQWMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxlQUFlO0NBQy9CLENBQUMsQ0FBQTtBQStDVCxNQUFNLGlCQUFpQixHQUFzQjtJQUMzQyxVQUFVLEVBQUUsVUFBVTtJQUN0QixVQUFVLEVBQUUsVUFBVTtDQUN2QixDQUFBO0FBQ0QsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLGVBQWU7S0FDckMsZ0JBQWdCLENBQUMsaUJBQWlCLENBQUM7S0FDbkMsYUFBYSxFQUFrQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgKi9cblxuLy8gQHRzLW5vY2hlY2tcblxuLy8gbm9pbnNwZWN0aW9uIEpTVW51c2VkR2xvYmFsU3ltYm9sc1xuXG4vLyBUaGlzIGZpbGUgd2FzIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGJ5IFRhblN0YWNrIFJvdXRlci5cbi8vIFlvdSBzaG91bGQgTk9UIG1ha2UgYW55IGNoYW5nZXMgaW4gdGhpcyBmaWxlIGFzIGl0IHdpbGwgYmUgb3ZlcndyaXR0ZW4uXG4vLyBBZGRpdGlvbmFsbHksIHlvdSBzaG91bGQgYWxzbyBleGNsdWRlIHRoaXMgZmlsZSBmcm9tIHlvdXIgbGludGVyIGFuZC9vciBmb3JtYXR0ZXIgdG8gcHJldmVudCBpdCBmcm9tIGJlaW5nIGNoZWNrZWQgb3IgbW9kaWZpZWQuXG5cbmltcG9ydCB7IFJvdXRlIGFzIHJvb3RSb3V0ZUltcG9ydCB9IGZyb20gJy4vcm91dGVzL19fcm9vdCdcbmltcG9ydCB7IFJvdXRlIGFzIHNwbGF0Um91dGVJbXBvcnQgfSBmcm9tICcuL3JvdXRlcy8kJ1xuaW1wb3J0IHsgUm91dGUgYXMgSW5kZXhSb3V0ZUltcG9ydCB9IGZyb20gJy4vLi4vLmxpdmVtYXJrL3JvdXRlcy9pbmRleCdcblxuY29uc3Qgc3BsYXRSb3V0ZSA9IHNwbGF0Um91dGVJbXBvcnQudXBkYXRlKHtcbiAgaWQ6ICcvJCcsXG4gIHBhdGg6ICcvJCcsXG4gIGdldFBhcmVudFJvdXRlOiAoKSA9PiByb290Um91dGVJbXBvcnQsXG59IGFzIGFueSlcbmNvbnN0IEluZGV4Um91dGUgPSBJbmRleFJvdXRlSW1wb3J0LnVwZGF0ZSh7XG4gIGlkOiAnLycsXG4gIHBhdGg6ICcvJyxcbiAgZ2V0UGFyZW50Um91dGU6ICgpID0+IHJvb3RSb3V0ZUltcG9ydCxcbn0gYXMgYW55KVxuXG5leHBvcnQgaW50ZXJmYWNlIEZpbGVSb3V0ZXNCeUZ1bGxQYXRoIHtcbiAgJy8nOiB0eXBlb2YgSW5kZXhSb3V0ZVxuICAnLyQnOiB0eXBlb2Ygc3BsYXRSb3V0ZVxufVxuZXhwb3J0IGludGVyZmFjZSBGaWxlUm91dGVzQnlUbyB7XG4gICcvJzogdHlwZW9mIEluZGV4Um91dGVcbiAgJy8kJzogdHlwZW9mIHNwbGF0Um91dGVcbn1cbmV4cG9ydCBpbnRlcmZhY2UgRmlsZVJvdXRlc0J5SWQge1xuICBfX3Jvb3RfXzogdHlwZW9mIHJvb3RSb3V0ZUltcG9ydFxuICAnLyc6IHR5cGVvZiBJbmRleFJvdXRlXG4gICcvJCc6IHR5cGVvZiBzcGxhdFJvdXRlXG59XG5leHBvcnQgaW50ZXJmYWNlIEZpbGVSb3V0ZVR5cGVzIHtcbiAgZmlsZVJvdXRlc0J5RnVsbFBhdGg6IEZpbGVSb3V0ZXNCeUZ1bGxQYXRoXG4gIGZ1bGxQYXRoczogJy8nIHwgJy8kJ1xuICBmaWxlUm91dGVzQnlUbzogRmlsZVJvdXRlc0J5VG9cbiAgdG86ICcvJyB8ICcvJCdcbiAgaWQ6ICdfX3Jvb3RfXycgfCAnLycgfCAnLyQnXG4gIGZpbGVSb3V0ZXNCeUlkOiBGaWxlUm91dGVzQnlJZFxufVxuZXhwb3J0IGludGVyZmFjZSBSb290Um91dGVDaGlsZHJlbiB7XG4gIEluZGV4Um91dGU6IHR5cGVvZiBJbmRleFJvdXRlXG4gIHNwbGF0Um91dGU6IHR5cGVvZiBzcGxhdFJvdXRlXG59XG5cbmRlY2xhcmUgbW9kdWxlICdAdGFuc3RhY2svcmVhY3Qtcm91dGVyJyB7XG4gIGludGVyZmFjZSBGaWxlUm91dGVzQnlQYXRoIHtcbiAgICAnLyQnOiB7XG4gICAgICBpZDogJy8kJ1xuICAgICAgcGF0aDogJy8kJ1xuICAgICAgZnVsbFBhdGg6ICcvJCdcbiAgICAgIHByZUxvYWRlclJvdXRlOiB0eXBlb2Ygc3BsYXRSb3V0ZUltcG9ydFxuICAgICAgcGFyZW50Um91dGU6IHR5cGVvZiByb290Um91dGVJbXBvcnRcbiAgICB9XG4gICAgJy8nOiB7XG4gICAgICBpZDogJy8nXG4gICAgICBwYXRoOiAnLydcbiAgICAgIGZ1bGxQYXRoOiAnLydcbiAgICAgIHByZUxvYWRlclJvdXRlOiB0eXBlb2YgSW5kZXhSb3V0ZUltcG9ydFxuICAgICAgcGFyZW50Um91dGU6IHR5cGVvZiByb290Um91dGVJbXBvcnRcbiAgICB9XG4gIH1cbn1cblxuY29uc3Qgcm9vdFJvdXRlQ2hpbGRyZW46IFJvb3RSb3V0ZUNoaWxkcmVuID0ge1xuICBJbmRleFJvdXRlOiBJbmRleFJvdXRlLFxuICBzcGxhdFJvdXRlOiBzcGxhdFJvdXRlLFxufVxuZXhwb3J0IGNvbnN0IHJvdXRlVHJlZSA9IHJvb3RSb3V0ZUltcG9ydFxuICAuX2FkZEZpbGVDaGlsZHJlbihyb290Um91dGVDaGlsZHJlbilcbiAgLl9hZGRGaWxlVHlwZXM8RmlsZVJvdXRlVHlwZXM+KClcblxuaW1wb3J0IHR5cGUgeyBnZXRSb3V0ZXIgfSBmcm9tICcuL3JvdXRlci50c3gnXG5pbXBvcnQgdHlwZSB7IGNyZWF0ZVN0YXJ0IH0gZnJvbSAnQHRhbnN0YWNrL3JlYWN0LXN0YXJ0J1xuZGVjbGFyZSBtb2R1bGUgJ0B0YW5zdGFjay9yZWFjdC1zdGFydCcge1xuICBpbnRlcmZhY2UgUmVnaXN0ZXIge1xuICAgIHNzcjogdHJ1ZVxuICAgIHJvdXRlcjogQXdhaXRlZDxSZXR1cm5UeXBlPHR5cGVvZiBnZXRSb3V0ZXI+PlxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/routes/$section.rss[.]xml.d.ts

@@ -0,0 +1,7 @@
+export declare const Route: import("@tanstack/router-core").Route<import("@tanstack/react-router").Register, any, "/$section/rss.xml", "/$section/rss.xml", "/$section/rss.xml", "/$section/rss.xml", undefined, import("@tanstack/react-router").ResolveParams<"/$section/rss.xml">, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, {
+    GET: ({ params }: {
+        params: {
+            section: string;
+        };
+    }) => Promise<Response>;
+}>;

package/build/routes/$section.rss[.]xml.js

@@ -0,0 +1,56 @@
+import { config } from "livemark:virtual";
+import { createFileRoute } from "@tanstack/react-router";
+import { sectionFlatArticles, sortedArticles } from "../content/article.js";
+import { renderRssFeed } from "../helpers/rss.js";
+const FEED_ITEM_LIMIT = 20;
+export const Route = createFileRoute("/$section/rss.xml")({
+    server: {
+        handlers: {
+            GET: async ({ params }) => {
+                if (!config.site) {
+                    return new Response("RSS requires `site` in livemark.config.ts", {
+                        status: 404,
+                    });
+                }
+                const prefix = `/${params.section}/`;
+                const section = config.sections?.find(s => s.type === "blog" && s.prefix === prefix);
+                if (!section || section.type !== "blog") {
+                    return new Response("Not found", { status: 404 });
+                }
+                const host = config.site.replace(/\/+$/, "");
+                const base = config.base ?? "";
+                const toAbsolute = (path) => `${host}${base}${path}`;
+                const paths = sectionFlatArticles.get(section.prefix) ?? [];
+                const items = [];
+                for (const path of paths) {
+                    if (items.length >= FEED_ITEM_LIMIT)
+                        break;
+                    const article = sortedArticles.find(a => a.path === path);
+                    if (!article?.date)
+                        continue;
+                    const link = toAbsolute(article.path);
+                    items.push({
+                        title: article.title,
+                        link,
+                        guid: link,
+                        description: article.description,
+                        pubDate: article.date,
+                        author: article.author,
+                        categories: article.tags,
+                    });
+                }
+                const xml = renderRssFeed({
+                    title: section.siteTitle ?? section.title,
+                    description: section.siteDescription ?? config.description ?? "",
+                    link: toAbsolute(section.prefix),
+                    feedLink: toAbsolute(`${section.prefix}rss.xml`),
+                    items,
+                });
+                return new Response(xml, {
+                    headers: { "Content-Type": "application/rss+xml; charset=utf-8" },
+                });
+            },
+        },
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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