@riebeckite/plugin-seo 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright Rerurate_514
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,110 @@
+# @riebeckite/plugin-seo
+
+SEO metadata, sitemap, robots.txt, and feed generation for Riebeckite.
+
+[日本語](./README_ja.md)
+
+## Overview
+
+`seo()` provides a `PluginSeoExtension` consumed by the Riebeckite app. It
+builds per-page SEO metadata and renders `/sitemap.xml`, `/robots.txt`, and
+RSS / Atom / JSON feeds.
+
+## Usage
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { seo } from "@riebeckite/plugin-seo";
+
+export default defineConfig({
+  // ...
+  plugins: [
+    seo({
+      siteName: "Riebeckite Blog",
+      defaultImage: "/ogp.png",
+      feed: { rss: true, atom: true, json: true },
+      sitemap: true,
+      robots: true,
+    }),
+  ],
+});
+```
+
+## Options
+
+| Option | Type | Description |
+| ------ | ---- | ----------- |
+| `siteName` | `string` | Site name used in page titles. Defaults to `site.title`. |
+| `defaultImage` | `string` | Default OG image. Falls back to `site.defaultOgImage`. |
+| `feed` | `{ rss?: boolean; atom?: boolean; json?: boolean }` | Feed output settings. |
+| `sitemap` | `boolean` | Sitemap output settings. |
+| `robots` | `boolean` | robots.txt output settings. |
+
+## Generated metadata
+
+### Articles (`buildArticleSeo`)
+
+- `title`: `"{title} | {siteName}"`
+- `description`: `frontmatter.description`, otherwise the first 160 characters
+  of the post text
+- `canonicalUrl`: `frontmatter.canonical`, otherwise the entry's resolved canonical permalink
+- `imageUrl`: `frontmatter.ogImage` / `frontmatter.image`, otherwise
+  `defaultImage` / `site.defaultOgImage`
+- `noindex`: `frontmatter.noindex === true`
+- `publishedTime`: `published` / `date` / `created`
+- `modifiedTime`: `updated`, falling back to the publish time
+- `tags`, `readingTimeMinutes`
+- JSON-LD: `BlogPosting` and `BreadcrumbList`
+
+### Websites (`buildWebsiteSeo`)
+
+Title, description, canonical URL, default image, and JSON-LD `WebSite` +
+`BreadcrumbList` for index, tag, and other non-article pages.
+
+## Feeds, sitemap, and robots
+
+| Function | Output |
+| -------- | ------ |
+| `renderSitemap` | `/sitemap.xml` — home page plus published, non-`noindex` entries |
+| `renderRobots` | `/robots.txt` — allow all plus sitemap link |
+| `renderRssFeed` | RSS 2.0 built from `config.site.feed` |
+| `renderAtomFeed` | Atom feed |
+| `renderJsonFeed` | JSON Feed 1.1 with `content_html` |
+
+Feed and sitemap entries are filtered with `isPublished`, exclude
+`noindex: true`, and are sorted by the most recent update first. Their URLs use
+each entry's resolved canonical `permalink` (`ContentManifestEntry.permalink`);
+they are never rebuilt from slugs.
+
+## Reading time
+
+`calculateReadingTime` counts CJK characters (500/min) and Latin words
+(220/min), rounding up to at least 1 minute.
+
+## Frontmatter fields
+
+| Field | Use |
+| ----- | --- |
+| `title` | Article title (falls back to the last slug segment) |
+| `description` | Meta description |
+| `canonical` | Canonical URL |
+| `image` / `ogImage` | OG image |
+| `published` / `date` / `created` | Publish time |
+| `updated` | Modified time |
+| `tags` | Keywords / feed tags |
+| `noindex` | `noindex` meta, feed and sitemap exclusion |
+
+## Exports
+
+- `seo(options?)` — plugin factory
+- Types: `SeoPluginOptions`, `FeedOptions`, `SeoMetadata`, `WebsiteSeoInput`,
+  `RenderableFeedEntry`
+- Helpers: `buildArticleSeo`, `buildWebsiteSeo`, `buildAbsoluteUrl`,
+  `buildPostUrl`, `getDescription`, `filterFeedEntries`,
+  `getEntryPublishedTime`, `getEntryUpdatedTime`, `getHtmlLanguage`,
+  `calculateReadingTime`, `renderSitemap`, `renderRobots`, `renderRssFeed`,
+  `renderAtomFeed`, `renderJsonFeed`
+
+## See also
+
+- [Plugin guide](../../docs/plugins_en.md)

package/README_ja.md

@@ -0,0 +1,68 @@
+# @riebeckite/plugin-seo
+
+記事のメタデータ、サイトマップ、robots.txt、RSS・Atom・JSON Feed をまとめて生成するプラグインです。アプリケーションはプラグインが提供する SEO 拡張を受け取り、各ページの出力に利用します。
+
+[English](./README.md)
+
+## 設定する
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { seo } from "@riebeckite/plugin-seo";
+
+export default defineConfig({
+  // ...
+  plugins: [
+    seo({
+      siteName: "Riebeckite Blog",
+      defaultImage: "/ogp.png",
+      feed: { rss: true, atom: true, json: true },
+      sitemap: true,
+      robots: true,
+    }),
+  ],
+});
+```
+
+| 項目 | 説明 |
+| --- | --- |
+| `siteName` | ページタイトルに使うサイト名。省略時は `site.title` |
+| `defaultImage` | 既定の OGP 画像。省略時は `site.defaultOgImage` |
+| `feed` | RSS、Atom、JSON Feed の出力を個別に有効化する |
+| `sitemap` | サイトマップを出力する |
+| `robots` | robots.txt を出力する |
+
+## 記事の frontmatter が出力を決める
+
+`buildArticleSeo()` は記事タイトル、説明、canonical URL、OGP 画像、公開・更新日時、タグ、読了時間を組み立て、`BlogPosting` と `BreadcrumbList` の JSON-LD を作ります。値は次の順で補完されます。
+
+| フィールド | 用途 |
+| --- | --- |
+| `title` | 記事タイトル。なければ slug の末尾 |
+| `description` | meta description。なければ本文の先頭 160 文字 |
+| `canonical` | 正規 URL。なければ解決済みの canonical permalink |
+| `image` / `ogImage` | OGP 画像。なければ設定上の既定画像 |
+| `published` / `date` / `created` | 公開日時 |
+| `updated` | 更新日時。なければ公開日時 |
+| `tags` | キーワードとフィードのタグ |
+| `noindex` | 検索エンジン向けの noindex と、サイトマップ・フィードからの除外 |
+
+記事以外には `buildWebsiteSeo()` を使えます。トップやタグ一覧向けに `WebSite` と `BreadcrumbList` の構造化データを作ります。
+
+## 公開物に含まれる記事
+
+サイトマップとフィードは、公開済みで `noindex: true` ではないエントリーだけを対象にし、更新日時の新しい順に並べます。URL には各エントリーの解決済み canonical `permalink`（`ContentManifestEntry.permalink`）を使い、slug から再構築しません。出力関数は `renderSitemap`、`renderRobots`、`renderRssFeed`、`renderAtomFeed`、`renderJsonFeed` です。
+
+読了時間は CJK 文字を毎分 500 文字、ラテン文字の単語を毎分 220 語として数え、最低 1 分に切り上げます。
+
+## 主なエクスポート
+
+- `seo(options?)`: プラグインを作成する
+- `buildArticleSeo`、`buildWebsiteSeo`: ページの SEO 情報を構築する
+- `renderSitemap`、`renderRobots`、`renderRssFeed`、`renderAtomFeed`、`renderJsonFeed`: 公開用ファイルを描画する
+- `calculateReadingTime`: 読了時間を計算する
+- 型: `SeoPluginOptions`、`FeedOptions`、`SeoMetadata`、`WebsiteSeoInput`、`RenderableFeedEntry`
+
+## 関連資料
+
+- [プラグインシステム](../../../docs/ja/plugin-system.md)

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { SeoMetadata, WebsiteSeoInput } from "@riebeckite/core";
+export { filterFeedEntries, getDescription, getEntryPublishedTime, getEntryUpdatedTime, getHtmlLanguage, } from "./src/content.js";
+export { renderAtomFeed, renderJsonFeed, renderRssFeed } from "./src/feeds.js";
+export { buildArticleSeo, buildWebsiteSeo } from "./src/metadata.js";
+export { seo } from "./src/plugin.js";
+export { renderRobots, renderSitemap } from "./src/site-files.js";
+export type { FeedOptions, RenderableFeedEntry, SeoPluginOptions, } from "./src/types.js";
+export { buildAbsoluteUrl, buildPostUrl } from "./src/url.js";

package/dist/index.js

@@ -0,0 +1,357 @@
+// src/content.ts
+import { isPublished, stripHtml } from "@riebeckite/core";
+function getDescription(post) {
+  const frontmatterDescription = post.frontmatter.description;
+  if (typeof frontmatterDescription === "string" && frontmatterDescription.trim()) {
+    return frontmatterDescription.trim();
+  }
+  return stripHtml(post.html).replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function filterFeedEntries(config, entries) {
+  return entries.filter((entry) => isPublished(config, entry.frontmatter)).filter((entry) => entry.frontmatter.noindex !== true).sort((a, b) => getSortableTime(b) - getSortableTime(a));
+}
+function getEntryPublishedTime(entry) {
+  return getIsoDate(
+    entry.frontmatter.published ?? entry.frontmatter.date ?? entry.frontmatter.created
+  ) ?? null;
+}
+function getEntryUpdatedTime(entry) {
+  return getIsoDate(entry.frontmatter.updated) ?? getEntryPublishedTime(entry);
+}
+function getHtmlLanguage(config) {
+  return config.site.locale.replace("_", "-");
+}
+function normalizeTags(tags) {
+  if (!Array.isArray(tags)) return [];
+  return tags.filter(
+    (tag) => typeof tag === "string" && tag.trim().length > 0
+  );
+}
+function getIsoDate(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function getSortableTime(entry) {
+  const value = entry.frontmatter.updated ?? entry.frontmatter.published ?? entry.frontmatter.date ?? entry.frontmatter.created;
+  if (value instanceof Date) return value.getTime();
+  if (typeof value !== "string") return 0;
+  const time = new Date(value).getTime();
+  return Number.isNaN(time) ? 0 : time;
+}
+
+// src/url.ts
+function buildAbsoluteUrl(config, pathOrUrl) {
+  if (!pathOrUrl) return config.site.baseUrl;
+  if (/^https?:\/\//.test(pathOrUrl)) return pathOrUrl;
+  return new URL(
+    pathOrUrl,
+    config.site.baseUrl || "https://example.com"
+  ).toString();
+}
+function buildPostUrl(config, permalink) {
+  return buildAbsoluteUrl(config, permalink);
+}
+
+// src/schema.ts
+function buildBreadcrumbSchema(config, items) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.name,
+      item: item.url || buildAbsoluteUrl(config, "/")
+    }))
+  };
+}
+function removeUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entryValue]) => entryValue !== void 0)
+  );
+}
+
+// src/xml.ts
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/feeds.ts
+function renderRssFeed(config, entries) {
+  const items = entries.map((entry) => {
+    const url = buildPostUrl(config, entry.permalink);
+    const pubDate = getEntryPublishedTime(entry);
+    return `<item><title>${escapeXml(entry.title)}</title><link>${escapeXml(url)}</link><guid>${escapeXml(url)}</guid><description>${escapeXml(getDescription(entry))}</description>${pubDate ? `<pubDate>${new Date(pubDate).toUTCString()}</pubDate>` : ""}</item>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>${escapeXml(config.site.feed.title)}</title><link>${escapeXml(buildAbsoluteUrl(config, "/"))}</link><description>${escapeXml(config.site.feed.description)}</description><language>${escapeXml(config.site.feed.language)}</language>${items.join("")}</channel></rss>`;
+}
+function renderAtomFeed(config, entries) {
+  const updated = entries.map(getEntryUpdatedTime).find(Boolean) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  const items = entries.map((entry) => {
+    const url = buildPostUrl(config, entry.permalink);
+    return `<entry><title>${escapeXml(entry.title)}</title><link href="${escapeXml(url)}"/><id>${escapeXml(url)}</id><updated>${escapeXml(getEntryUpdatedTime(entry) ?? updated)}</updated><summary>${escapeXml(getDescription(entry))}</summary></entry>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?><feed xmlns="http://www.w3.org/2005/Atom"><title>${escapeXml(config.site.feed.title)}</title><link href="${escapeXml(buildAbsoluteUrl(config, "/"))}"/><link rel="self" href="${escapeXml(buildAbsoluteUrl(config, "/atom.xml"))}"/><id>${escapeXml(buildAbsoluteUrl(config, "/"))}</id><updated>${escapeXml(updated)}</updated>${items.join("")}</feed>`;
+}
+function renderJsonFeed(config, entries) {
+  return JSON.stringify({
+    version: "https://jsonfeed.org/version/1.1",
+    title: config.site.feed.title,
+    home_page_url: buildAbsoluteUrl(config, "/"),
+    feed_url: buildAbsoluteUrl(config, "/feed.json"),
+    description: config.site.feed.description,
+    language: getHtmlLanguage(config),
+    items: entries.map((entry) => {
+      const url = buildPostUrl(config, entry.permalink);
+      return removeUndefined({
+        id: url,
+        url,
+        title: entry.title,
+        content_html: entry.html,
+        summary: getDescription(entry),
+        date_published: getEntryPublishedTime(entry) ?? void 0,
+        date_modified: getEntryUpdatedTime(entry) ?? void 0,
+        tags: normalizeTags(entry.frontmatter.tags)
+      });
+    })
+  });
+}
+
+// src/metadata.ts
+import { calculateReadingTime } from "@riebeckite/core";
+function buildArticleSeo(config, options, permalink, post) {
+  const siteName = getSiteName(config, options);
+  const title = getArticleTitle(config, permalink, post.frontmatter.title);
+  const canonicalUrl = buildCanonicalUrl(
+    config,
+    post.frontmatter.canonical,
+    permalink
+  );
+  const description = getDescription(post) || config.site.description;
+  const imageUrl = buildImageUrl(
+    config,
+    options,
+    post.frontmatter.ogImage ?? post.frontmatter.image
+  );
+  const publishedTime = getIsoDate2(
+    post.frontmatter.published ?? post.frontmatter.date ?? post.frontmatter.created
+  );
+  const modifiedTime = getIsoDate2(post.frontmatter.updated) ?? publishedTime;
+  const tags = normalizeTags(post.frontmatter.tags);
+  const readingTimeMinutes = calculateReadingTime(post.html);
+  const breadcrumb = buildBreadcrumbSchema(config, [
+    { name: siteName, url: buildAbsoluteUrl(config, "/") },
+    { name: title, url: canonicalUrl }
+  ]);
+  return {
+    title: buildPageTitle(siteName, title),
+    description,
+    canonicalUrl,
+    imageUrl,
+    type: "article",
+    noindex: post.frontmatter.noindex === true,
+    publishedTime,
+    modifiedTime,
+    tags,
+    readingTimeMinutes,
+    jsonLd: [
+      removeUndefined({
+        "@context": "https://schema.org",
+        "@type": "BlogPosting",
+        headline: title,
+        description,
+        url: canonicalUrl,
+        image: imageUrl ? [imageUrl] : void 0,
+        datePublished: publishedTime,
+        dateModified: modifiedTime,
+        author: config.site.author ? { "@type": "Person", name: config.site.author } : void 0,
+        publisher: { "@type": "Organization", name: siteName },
+        keywords: tags.length > 0 ? tags.join(", ") : void 0,
+        timeRequired: readingTimeMinutes ? `PT${readingTimeMinutes}M` : void 0,
+        inLanguage: getHtmlLanguage(config)
+      }),
+      breadcrumb
+    ]
+  };
+}
+function buildWebsiteSeo(config, options, input) {
+  const siteName = getSiteName(config, options);
+  const canonicalUrl = buildAbsoluteUrl(config, input.path);
+  const description = input.description || config.site.description;
+  const imageUrl = buildImageUrl(config, options);
+  const title = input.kind === "tag" ? input.title : buildPageTitle(siteName, input.title);
+  return {
+    title,
+    description,
+    canonicalUrl,
+    imageUrl,
+    type: "website",
+    noindex: false,
+    tags: [],
+    jsonLd: [
+      removeUndefined({
+        "@context": "https://schema.org",
+        "@type": "WebSite",
+        name: siteName,
+        description,
+        url: canonicalUrl,
+        inLanguage: getHtmlLanguage(config)
+      }),
+      buildBreadcrumbSchema(config, [
+        { name: siteName, url: buildAbsoluteUrl(config, "/") }
+      ])
+    ]
+  };
+}
+function buildCanonicalUrl(config, canonical, permalink) {
+  if (typeof canonical === "string" && canonical.trim()) {
+    return buildAbsoluteUrl(config, canonical.trim());
+  }
+  return buildPostUrl(config, permalink);
+}
+function buildImageUrl(config, options, value) {
+  const image = value || options.defaultImage || config.site.defaultOgImage;
+  return image ? buildAbsoluteUrl(config, image) : "";
+}
+function getSiteName(config, options) {
+  return options.siteName || config.site.title;
+}
+function getArticleTitle(config, slug, value) {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  const lastSegment = slug.split("/").filter(Boolean).at(-1);
+  return lastSegment || config.site.title;
+}
+function buildPageTitle(siteName, title) {
+  if (!title || title === siteName) return siteName;
+  return `${title} | ${siteName}`;
+}
+function getIsoDate2(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+
+// src/plugin.ts
+import { definePlugin } from "@riebeckite/core";
+
+// src/site-files.ts
+function renderSitemap(config, entries) {
+  const urls = [
+    { loc: buildAbsoluteUrl(config, "/"), lastmod: void 0 },
+    ...filterFeedEntries(config, entries).filter((entry) => entry.permalink !== "/").map((entry) => ({
+      loc: buildPostUrl(config, entry.permalink),
+      lastmod: getEntryUpdatedTime(entry)
+    }))
+  ];
+  const body = urls.map(
+    (url) => `<url><loc>${escapeXml(url.loc)}</loc>${url.lastmod ? `<lastmod>${escapeXml(url.lastmod)}</lastmod>` : ""}</url>`
+  ).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${body}</urlset>`;
+}
+function renderRobots(config) {
+  return [
+    "User-agent: *",
+    "Allow: /",
+    `Sitemap: ${buildAbsoluteUrl(config, "/sitemap.xml")}`,
+    ""
+  ].join("\n");
+}
+
+// src/endpoints.ts
+function createSeoEndpoints(options) {
+  return [
+    options.sitemap === true ? {
+      path: "/sitemap.xml",
+      handler: ({ config, manifest }) => ({
+        headers: { "content-type": "application/xml; charset=utf-8" },
+        body: renderSitemap(config, manifest.entries)
+      })
+    } : null,
+    options.robots === true ? {
+      path: "/robots.txt",
+      handler: ({ config }) => ({
+        headers: { "content-type": "text/plain; charset=utf-8" },
+        body: renderRobots(config)
+      })
+    } : null,
+    options.feed?.rss === true ? {
+      path: "/feed.xml",
+      handler: ({ config, manifest }) => ({
+        headers: { "content-type": "application/rss+xml; charset=utf-8" },
+        body: renderRssFeed(
+          config,
+          filterFeedEntries(config, manifest.entries)
+        )
+      })
+    } : null,
+    options.feed?.atom === true ? {
+      path: "/atom.xml",
+      handler: ({ config, manifest }) => ({
+        headers: { "content-type": "application/atom+xml; charset=utf-8" },
+        body: renderAtomFeed(
+          config,
+          filterFeedEntries(config, manifest.entries)
+        )
+      })
+    } : null,
+    options.feed?.json === true ? {
+      path: "/feed.json",
+      handler: ({ config, manifest }) => ({
+        json: JSON.parse(
+          renderJsonFeed(
+            config,
+            filterFeedEntries(config, manifest.entries)
+          )
+        )
+      })
+    } : null
+  ].filter((endpoint) => endpoint !== null);
+}
+
+// src/plugin.ts
+function seo(options = {}) {
+  return definePlugin({
+    name: "seo",
+    options,
+    seo: {
+      buildArticleSeo: (config, permalink, post) => buildArticleSeo(config, options, permalink, post),
+      buildWebsiteSeo: (config, input) => buildWebsiteSeo(config, options, input),
+      buildAbsoluteUrl,
+      buildPostUrl,
+      getDescription,
+      getEntryPublishedTime,
+      getEntryUpdatedTime,
+      getHtmlLanguage,
+      renderSitemap,
+      renderRobots,
+      renderRssFeed,
+      renderAtomFeed,
+      renderJsonFeed
+    },
+    endpoints: createSeoEndpoints(options)
+  });
+}
+export {
+  buildAbsoluteUrl,
+  buildArticleSeo,
+  buildPostUrl,
+  buildWebsiteSeo,
+  filterFeedEntries,
+  getDescription,
+  getEntryPublishedTime,
+  getEntryUpdatedTime,
+  getHtmlLanguage,
+  renderAtomFeed,
+  renderJsonFeed,
+  renderRobots,
+  renderRssFeed,
+  renderSitemap,
+  seo
+};

package/dist/src/content.d.ts

@@ -0,0 +1,7 @@
+import type { ContentManifestEntry, PostContent, ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export declare function getDescription(post: Pick<PostContent, "frontmatter" | "html">): string;
+export declare function filterFeedEntries(config: ResolvedRiebeckiteConfig, entries: ContentManifestEntry[]): ContentManifestEntry[];
+export declare function getEntryPublishedTime(entry: ContentManifestEntry): string | null;
+export declare function getEntryUpdatedTime(entry: ContentManifestEntry): string | null;
+export declare function getHtmlLanguage(config: ResolvedRiebeckiteConfig): string;
+export declare function normalizeTags(tags: unknown): string[];

package/dist/src/endpoints.d.ts

@@ -0,0 +1,3 @@
+import type { PluginEndpoint } from "@riebeckite/core";
+import type { SeoPluginOptions } from "./types.js";
+export declare function createSeoEndpoints(options: SeoPluginOptions): PluginEndpoint[];

package/dist/src/feeds.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import type { RenderableFeedEntry } from "./types.js";
+export declare function renderRssFeed(config: ResolvedRiebeckiteConfig, entries: RenderableFeedEntry[]): string;
+export declare function renderAtomFeed(config: ResolvedRiebeckiteConfig, entries: RenderableFeedEntry[]): string;
+export declare function renderJsonFeed(config: ResolvedRiebeckiteConfig, entries: RenderableFeedEntry[]): string;

package/dist/src/metadata.d.ts

@@ -0,0 +1,4 @@
+import type { PostContent, ResolvedRiebeckiteConfig, SeoMetadata, WebsiteSeoInput } from "@riebeckite/core";
+import type { SeoPluginOptions } from "./types.js";
+export declare function buildArticleSeo(config: ResolvedRiebeckiteConfig, options: SeoPluginOptions, permalink: string, post: PostContent): SeoMetadata;
+export declare function buildWebsiteSeo(config: ResolvedRiebeckiteConfig, options: SeoPluginOptions, input: WebsiteSeoInput): SeoMetadata;

package/dist/src/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { SeoPluginOptions } from "./types.js";
+export declare function seo(options?: SeoPluginOptions): import("@riebeckite/core").RiebeckitePlugin<SeoPluginOptions>;

package/dist/src/schema.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export declare function buildBreadcrumbSchema(config: ResolvedRiebeckiteConfig, items: {
+    name: string;
+    url: string;
+}[]): Record<string, unknown>;
+export declare function removeUndefined<T extends Record<string, unknown>>(value: T): T;

package/dist/src/site-files.d.ts

@@ -0,0 +1,3 @@
+import type { ContentManifestEntry, ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export declare function renderSitemap(config: ResolvedRiebeckiteConfig, entries: ContentManifestEntry[]): string;
+export declare function renderRobots(config: ResolvedRiebeckiteConfig): string;

package/dist/src/types.d.ts

@@ -0,0 +1,16 @@
+import type { ContentManifestEntry } from "@riebeckite/core";
+export type FeedOptions = {
+    rss?: boolean;
+    atom?: boolean;
+    json?: boolean;
+};
+export type SeoPluginOptions = {
+    siteName?: string;
+    defaultImage?: string;
+    feed?: FeedOptions;
+    sitemap?: boolean;
+    robots?: boolean;
+};
+export type RenderableFeedEntry = ContentManifestEntry & {
+    html?: string;
+};

package/dist/src/url.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export declare function buildAbsoluteUrl(config: ResolvedRiebeckiteConfig, pathOrUrl: string): string;
+export declare function buildPostUrl(config: ResolvedRiebeckiteConfig, permalink: string): string;

package/dist/src/xml.d.ts

@@ -0,0 +1 @@
+export declare function escapeXml(value: string): string;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@riebeckite/plugin-seo",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@riebeckite/core": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/seo"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "SEO metadata, sitemaps, feeds, and robots.txt for Riebeckite.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "seo",
+    "sitemap"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs"
+  }
+}