@riebeckite/plugin-rename 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,123 @@
+# @riebeckite/plugin-rename
+
+Reduces broken URLs after notes are renamed or moved by turning detected
+renames into permanent redirects on the existing Riebeckite redirect
+machinery.
+
+[日本語](./README_ja.md)
+
+## Basic usage
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { renamePlugin } from "@riebeckite/plugin-rename";
+
+export default defineConfig({
+  plugins: [
+    renamePlugin({
+      status: 308,
+      onUnexpectedRemoval: "warning",
+    }),
+  ],
+});
+```
+
+When a note moves, the plugin compares the current routes with the route lock
+saved during the previous build. If it can identify the same note, it records a
+redirect from the old permalink to the new one in `manifest.redirects`, which
+Core already consumes for redirect pages and deploy files.
+
+## How it works
+
+```text
+current entries (published only)
+        │
+        ▼
+buildRouteLock ──► current RouteLock
+        │                    │
+        │                    ▼
+        └──────────► diffRoutes(previous, current)
+                             │
+              ┌──────────────┴───────────────┐
+              ▼                              ▼
+        rename redirects                diagnostics
+        (merged + chain-collapsed)      (ambiguous / removed)
+              │
+              ▼
+     manifest.redirects  ◄── never overwrites an existing key
+              │
+              ▼
+     context.cache "routes.lock"
+```
+
+Detection precedence is strict and never fuzzy:
+
+1. **Explicit identity** — the entry's frontmatter `id` matches a lock route's
+   `id`.
+2. **Exact content hash** — `sha256(entry.html)` matches exactly one new route.
+3. Otherwise the route is treated as removed.
+
+Multiple matching candidates (or none) produce no redirect. Ambiguous matches
+emit a `rename-ambiguous` diagnostic; unmatched removals emit a diagnostic whose
+severity follows `onUnexpectedRemoval`.
+
+## State
+
+The plugin never writes files directly. The only cross-build state is the route
+lock, stored through `context.cache` under the key `routes.lock`. The cache is
+created under `<content.dir>/../.riebeckite/cache` and is gitignored, so the
+lock is machine-local and is regenerated from scratch when missing or corrupt.
+
+Because the lock is machine-local, the first build on a fresh machine has no
+history and cannot detect a rename that happened before the lock existed.
+
+## Options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | Enables rename detection |
+| `status` | `301 \| 302 \| 307 \| 308` | `308` | HTTP status for new rename redirects |
+| `onUnexpectedRemoval` | `"info" \| "warning" \| "error"` | `"warning"` | Severity when a route disappears without rename evidence |
+
+## Rules and guarantees
+
+- Only entries passing `isPublished` are considered. Private or unpublished
+  notes never enter the lock and never produce redirects.
+- Existing `manifest.redirects` keys are never overwritten, so Permalink's
+  `redirect_from` always wins.
+- Permanent redirect chains are collapsed transitively (`A → B`, `B → C`
+  becomes `A → C`).
+- The lock is deterministic: route keys and redirects are sorted, with no
+  timestamps or randomness.
+- Redirects are replayed on every build, so the CLI build and the SSG build
+  reproduce the same redirects.
+
+## Exports
+
+Functions:
+
+- `renamePlugin(options?)` / `rename(options?)`
+- `diffRoutes(previous, current, options?)`
+- `buildRouteLock(entries, isPublished)`
+- `collapseRedirects(rules)`
+- `applyRouteRedirects(manifest, rules)`
+- `parseRouteLock(value)`, `emptyRouteLock()`, `hashContent(html)`
+
+Types:
+
+- `RenameOptions`
+- `RouteLock`, `RouteLockRoute`, `RouteLockRedirect`, `RedirectRule`
+- `DiffRoutesOptions`, `DiffRoutesResult`, `RenameDiagnostic`
+
+## Limitations
+
+- Git-based rename detection is not implemented. It would require filesystem or
+  repository access, which plugin code intentionally avoids. Rename detection
+  relies on frontmatter `id` and on exact content hashes only.
+- A rename in which both the `id` is absent and the HTML body changes cannot be
+  detected and is reported as an unexpected removal.
+
+## See also
+
+- [Permalink plugin](../permalink/README_en.md) — stable URLs and `redirect_from`
+- [Plugin guide](../../../docs/en/plugin-system.md)

package/README_ja.md

@@ -0,0 +1,103 @@
+# @riebeckite/plugin-rename
+
+ノートのリネームや移動で発生するリンク切れを減らすプラグインです。検出したリネームを、Riebeckite が既に持つリダイレクト機構（`manifest.redirects`）に恒久的なリダイレクトとして登録します。
+
+[English](./README_en.md)
+
+## 基本的な使い方
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { renamePlugin } from "@riebeckite/plugin-rename";
+
+export default defineConfig({
+  plugins: [
+    renamePlugin({
+      status: 308,
+      onUnexpectedRemoval: "warning",
+    }),
+  ],
+});
+```
+
+ノートが移動すると、プラグインは現在のルートと、前回のビルドで保存したルートロックを比較します。同一のノートだと判定できた場合は、旧パーマリンクから新パーマリンクへのリダイレクトを `manifest.redirects` に記録します。Core はこのリダイレクトをリダイレクトページやデプロイ用ファイルとしてそのまま利用します。
+
+## 仕組み
+
+```text
+現在のエントリ（公開分のみ）
+        │
+        ▼
+buildRouteLock ──► 現在の RouteLock
+        │                    │
+        │                    ▼
+        └──────────► diffRoutes(前回, 今回)
+                             │
+              ┌──────────────┴───────────────┐
+              ▼                              ▼
+        リネームのリダイレクト            診断メッセージ
+        （統合 + チェーン集約）          （曖昧 / 消失）
+              │
+              ▼
+     manifest.redirects  ◄── 既存キーは上書きしない
+              │
+              ▼
+     context.cache "routes.lock"
+```
+
+判定の優先順位は厳密で、あいまい一致は行いません。
+
+1. **明示的な同一性** — エントリの frontmatter `id` がロック内のルートの `id` と一致する。
+2. **内容ハッシュの完全一致** — `sha256(entry.html)` が新しいルートちょうど 1 件と一致する。
+3. どちらも該当しない場合、そのルートは消失とみなす。
+
+候補が複数ある場合、または 1 件もない場合はリダイレクトを作りません。曖昧一致では `rename-ambiguous` 診断を、対応の取れない消失では `onUnexpectedRemoval` に従った重要度の診断を出力します。
+
+## 状態の保存
+
+プラグインが直接ファイルを書き込むことはありません。ビルドをまたぐ状態はルートロックのみで、`context.cache` の `routes.lock` キーに保存します。キャッシュは `<content.dir>/../.riebeckite/cache` に作られて gitignore の対象なので、ロックはマシンローカルです。存在しない場合や壊れている場合は空のロックから再生成します。
+
+ロックがマシンローカルであるため、新しいマシンでの初回ビルドには履歴がなく、ロックが存在する前に起きたリネームは検出できません。
+
+## オプション
+
+| オプション | 型 | 既定値 | 説明 |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | リネーム検出を有効にする |
+| `status` | `301 \| 302 \| 307 \| 308` | `308` | 新規リネームリダイレクトの HTTP ステータス |
+| `onUnexpectedRemoval` | `"info" \| "warning" \| "error"` | `"warning"` | リネームの根拠なくルートが消えたときの重要度 |
+
+## ルールと保証
+
+- `isPublished` を満たすエントリだけを対象にします。非公開ノートはロックにもリダイレクトにも入りません。
+- 既存の `manifest.redirects` のキーは上書きしません。Permalink の `redirect_from` が常に優先されます。
+- 恒久的なリダイレクトのチェーンは推移的に集約します（`A → B` と `B → C` は `A → C` になる）。
+- ロックは決定的です。ルートキーとリダイレクトをソートし、タイムスタンプや乱数を使いません。
+- リダイレクトは毎ビルドで再適用されるため、CLI ビルドと SSG ビルドが同じリダイレクトを再現します。
+
+## エクスポート
+
+関数:
+
+- `renamePlugin(options?)` / `rename(options?)`
+- `diffRoutes(previous, current, options?)`
+- `buildRouteLock(entries, isPublished)`
+- `collapseRedirects(rules)`
+- `applyRouteRedirects(manifest, rules)`
+- `parseRouteLock(value)`、`emptyRouteLock()`、`hashContent(html)`
+
+型:
+
+- `RenameOptions`
+- `RouteLock`、`RouteLockRoute`、`RouteLockRedirect`、`RedirectRule`
+- `DiffRoutesOptions`、`DiffRoutesResult`、`RenameDiagnostic`
+
+## 制限事項
+
+- git によるリネーム検出は実装していません。ファイルシステムやリポジトリへのアクセスが必要であり、プラグインコードは意図的にそれを避けています。リネーム検出は frontmatter `id` と内容ハッシュの完全一致のみに依存します。
+- `id` がなく、本文 HTML も変化したリネームは検出できず、予期しない消失として報告されます。
+
+## 関連
+
+- [Permalink プラグイン](../permalink/README_ja.md) — 安定した URL と `redirect_from`
+- [プラグインガイド](../../../docs/ja/plugin-system.md)

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { type RiebeckitePlugin } from "@riebeckite/core";
+import { type RedirectStatus } from "./src/lock.js";
+export type { DiffRoutesOptions, DiffRoutesResult, ManifestRedirect, RedirectRule, RedirectSink, RedirectStatus, RenameDiagnostic, RouteLock, RouteLockRedirect, RouteLockRoute, RouteLockSourceEntry, } from "./src/lock.js";
+export { applyRouteRedirects, buildRouteLock, collapseRedirects, diffRoutes, emptyRouteLock, hashContent, isRedirectStatus, parseRouteLock, } from "./src/lock.js";
+export type RenameOptions = {
+    /** Enables rename detection and redirect emission. Defaults to `true`. */
+    enabled?: boolean;
+    /** HTTP status for newly discovered rename redirects. Defaults to `308`. */
+    status?: RedirectStatus;
+    /** Severity for routes that disappear without rename evidence. Defaults to `"warning"`. */
+    onUnexpectedRemoval?: "info" | "warning" | "error";
+};
+/**
+ * Reduces broken URLs after note renames by reusing the existing redirect
+ * machinery (`manifest.redirects`). The only cross-build state is a JSON route
+ * lock persisted through `context.cache`; no files are written directly.
+ */
+export declare function renamePlugin(options?: RenameOptions): RiebeckitePlugin<RenameOptions>;
+export declare const rename: typeof renamePlugin;

package/dist/index.js

@@ -0,0 +1,305 @@
+// index.ts
+import {
+  definePlugin,
+  isPublished
+} from "@riebeckite/core";
+
+// src/lock.ts
+import { createHash } from "node:crypto";
+var LOCK_VERSION = 1;
+function hashContent(html) {
+  return createHash("sha256").update(html, "utf8").digest("hex");
+}
+function emptyRouteLock() {
+  return { version: LOCK_VERSION, routes: {}, redirects: [] };
+}
+function isRedirectStatus(value) {
+  return value === 301 || value === 302 || value === 307 || value === 308;
+}
+function buildRouteLock(entries, isPublished2) {
+  const routes = {};
+  for (const entry of entries) {
+    if (!isPublished2(entry.frontmatter)) continue;
+    const id = readId(entry.frontmatter);
+    routes[entry.slug] = id ? { permalink: entry.permalink, contentHash: hashContent(entry.html), id } : { permalink: entry.permalink, contentHash: hashContent(entry.html) };
+  }
+  return { version: LOCK_VERSION, routes: sortRoutes(routes), redirects: [] };
+}
+function parseRouteLock(value) {
+  if (!isRecord(value) || value.version !== LOCK_VERSION) return void 0;
+  if (!isRecord(value.routes)) return void 0;
+  if (!Array.isArray(value.redirects)) return void 0;
+  const routes = {};
+  for (const [slug, raw] of Object.entries(value.routes)) {
+    if (slug.length === 0 || !isRecord(raw)) return void 0;
+    const { permalink, contentHash } = raw;
+    if (typeof permalink !== "string" || typeof contentHash !== "string")
+      return void 0;
+    let id;
+    if (raw.id !== void 0) {
+      if (typeof raw.id !== "string") return void 0;
+      id = raw.id;
+    }
+    routes[slug] = id === void 0 ? { permalink, contentHash } : { permalink, contentHash, id };
+  }
+  const redirects = [];
+  for (const raw of value.redirects) {
+    if (!isRecord(raw)) return void 0;
+    const { from, to, status, reason } = raw;
+    if (typeof from !== "string" || typeof to !== "string") return void 0;
+    if (!isRedirectStatus(status)) return void 0;
+    if (reason !== "rename" && reason !== "id") return void 0;
+    redirects.push({ from, to, status, reason });
+  }
+  return {
+    version: LOCK_VERSION,
+    routes: sortRoutes(routes),
+    redirects: collapseRedirects(redirects)
+  };
+}
+function diffRoutes(previous, current, options = {}) {
+  const status = options.status ?? 308;
+  const removalSeverity = options.onUnexpectedRemoval ?? "warning";
+  const prev = parseRouteLock(previous) ?? emptyRouteLock();
+  const curr = parseRouteLock(current) ?? emptyRouteLock();
+  const added = [];
+  const diagnostics = [];
+  const candidates = [];
+  for (const slug of sortedKeys(curr.routes)) {
+    const route = curr.routes[slug];
+    if (!route) continue;
+    const before = prev.routes[slug];
+    if (before && before.permalink === route.permalink) continue;
+    candidates.push({ slug, route });
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (const slug of sortedKeys(prev.routes)) {
+    const before = prev.routes[slug];
+    if (!before) continue;
+    const after = curr.routes[slug];
+    if (after && after.permalink === before.permalink) continue;
+    const idMatches = before.id === void 0 ? [] : candidates.filter(
+      (candidate) => !used.has(candidate.slug) && candidate.route.id === before.id
+    );
+    let matchedBy;
+    let match;
+    let ambiguous = 0;
+    if (idMatches.length === 1) {
+      match = idMatches[0];
+      matchedBy = "id";
+    } else if (idMatches.length > 1) {
+      ambiguous = idMatches.length;
+    } else {
+      const hashMatches = candidates.filter(
+        (candidate) => !used.has(candidate.slug) && candidate.route.contentHash === before.contentHash
+      );
+      if (hashMatches.length === 1) {
+        match = hashMatches[0];
+        matchedBy = "rename";
+      } else if (hashMatches.length > 1) {
+        ambiguous = hashMatches.length;
+      }
+    }
+    if (match && matchedBy) {
+      used.add(match.slug);
+      if (match.route.permalink !== before.permalink) {
+        added.push({
+          from: before.permalink,
+          to: match.route.permalink,
+          status,
+          reason: matchedBy
+        });
+      }
+      continue;
+    }
+    if (ambiguous > 0) {
+      diagnostics.push({
+        code: "rename-ambiguous",
+        severity: "warning",
+        message: `Cannot resolve the previous route "${before.permalink}" (slug "${slug}"): ${ambiguous} candidates share the same ${before.id === void 0 ? "content hash" : "id"}.`,
+        slug,
+        suggestion: 'Add a stable frontmatter "id" so the note can be identified after a rename.'
+      });
+      continue;
+    }
+    diagnostics.push({
+      code: "rename-removed",
+      severity: removalSeverity,
+      message: `Route "${before.permalink}" (slug "${slug}") disappeared without rename evidence and was dropped from the route lock.`,
+      slug
+    });
+  }
+  const lock = {
+    version: LOCK_VERSION,
+    routes: sortRoutes({ ...curr.routes }),
+    redirects: collapseRedirects([
+      ...prev.redirects,
+      ...curr.redirects,
+      ...added
+    ])
+  };
+  return { lock, added, diagnostics };
+}
+function collapseRedirects(rules) {
+  const byFrom = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (!rule) continue;
+    if (rule.from === rule.to) continue;
+    byFrom.set(rule.from, { ...rule });
+  }
+  const collapsed = [];
+  for (const from of [...byFrom.keys()].sort()) {
+    const first = byFrom.get(from);
+    if (!first) continue;
+    const visited = /* @__PURE__ */ new Set([from]);
+    let to = first.to;
+    while (!visited.has(to)) {
+      const next = byFrom.get(to);
+      if (!next) break;
+      visited.add(to);
+      to = next.to;
+    }
+    if (to === from) continue;
+    collapsed.push({
+      from,
+      to,
+      status: first.status,
+      reason: first.reason
+    });
+  }
+  return collapsed;
+}
+function applyRouteRedirects(manifest, rules) {
+  const applied = [];
+  for (const rule of rules) {
+    if (manifest.redirects.has(rule.from)) continue;
+    if (manifest.byPermalink.has(rule.from)) continue;
+    const target = manifest.byPermalink.get(rule.to);
+    if (!target) continue;
+    manifest.redirects.set(rule.from, {
+      path: rule.to,
+      status: rule.status,
+      slug: target.slug
+    });
+    applied.push(rule);
+  }
+  return applied;
+}
+function readId(frontmatter) {
+  const value = frontmatter.id;
+  if (typeof value !== "string") return void 0;
+  const id = value.trim();
+  return id.length > 0 ? id : void 0;
+}
+function sortRoutes(routes) {
+  const sorted = {};
+  for (const slug of sortedKeys(routes)) {
+    const route = routes[slug];
+    if (route) sorted[slug] = route;
+  }
+  return sorted;
+}
+function sortedKeys(routes) {
+  return Object.keys(routes).sort();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// index.ts
+var PLUGIN_NAME = "rename";
+var LOCK_KEY = "routes.lock";
+var CACHE_VERSION = "1";
+var LOCK_MESSAGE = "Rename plugin: route lock could not be used; starting from an empty lock.";
+function renamePlugin(options = {}) {
+  const enabled = options.enabled ?? true;
+  const status = options.status ?? 308;
+  const onUnexpectedRemoval = options.onUnexpectedRemoval ?? "warning";
+  if (![301, 302, 307, 308].includes(status)) {
+    throw new Error(`Rename plugin: invalid redirect status ${status}.`);
+  }
+  if (!["info", "warning", "error"].includes(onUnexpectedRemoval)) {
+    throw new Error(
+      `Rename plugin: invalid onUnexpectedRemoval severity "${onUnexpectedRemoval}".`
+    );
+  }
+  return definePlugin({
+    name: PLUGIN_NAME,
+    options,
+    cacheVersion: CACHE_VERSION,
+    enabled,
+    onManifestCreated: async ({
+      manifest,
+      config,
+      cache,
+      diagnostics,
+      logger
+    }) => {
+      if (!enabled) return;
+      if (!config) {
+        logger.warn(
+          "Rename plugin: no resolved config is available; skipping rename detection."
+        );
+        return;
+      }
+      const previous = await readLock(cache, logger);
+      const current = buildRouteLock(
+        manifest.entries,
+        (frontmatter) => isPublished(config, frontmatter)
+      );
+      const result = diffRoutes(previous, current, {
+        status,
+        onUnexpectedRemoval
+      });
+      for (const diagnostic of result.diagnostics) {
+        diagnostics.push(renameDiagnostic(diagnostic));
+      }
+      applyRouteRedirects(manifest, result.lock.redirects);
+      await writeLock(cache, result.lock, logger);
+    }
+  });
+}
+var rename = renamePlugin;
+async function readLock(cache, logger) {
+  try {
+    const raw = await cache.get(LOCK_KEY);
+    if (raw === void 0) return emptyRouteLock();
+    const parsed = parseRouteLock(raw);
+    if (!parsed) {
+      logger.warn(LOCK_MESSAGE, { key: LOCK_KEY });
+      return emptyRouteLock();
+    }
+    return parsed;
+  } catch (error) {
+    logger.warn(LOCK_MESSAGE, { key: LOCK_KEY, error: messageOf(error) });
+    return emptyRouteLock();
+  }
+}
+async function writeLock(cache, lock, logger) {
+  try {
+    await cache.set(LOCK_KEY, lock);
+  } catch (error) {
+    logger.warn("Rename plugin: route lock could not be persisted.", {
+      key: LOCK_KEY,
+      error: messageOf(error)
+    });
+  }
+}
+function renameDiagnostic(diagnostic) {
+  return { pluginName: PLUGIN_NAME, ...diagnostic };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  applyRouteRedirects,
+  buildRouteLock,
+  collapseRedirects,
+  diffRoutes,
+  emptyRouteLock,
+  hashContent,
+  isRedirectStatus,
+  parseRouteLock,
+  rename,
+  renamePlugin
+};

package/dist/src/lock.d.ts

@@ -0,0 +1,93 @@
+export type RedirectStatus = 301 | 302 | 307 | 308;
+export type RouteLockRoute = {
+    permalink: string;
+    contentHash: string;
+    id?: string;
+};
+export type RouteLockRedirect = {
+    from: string;
+    to: string;
+    status: RedirectStatus;
+    reason: "rename" | "id";
+};
+export type RouteLock = {
+    version: 1;
+    routes: Record<string, RouteLockRoute>;
+    redirects: RouteLockRedirect[];
+};
+export type RedirectRule = RouteLock["redirects"][number];
+export type RenameDiagnostic = {
+    code: string;
+    severity: "info" | "warning" | "error";
+    message: string;
+    slug?: string;
+    suggestion?: string;
+};
+export type DiffRoutesResult = {
+    lock: RouteLock;
+    added: RedirectRule[];
+    diagnostics: RenameDiagnostic[];
+};
+export type DiffRoutesOptions = {
+    status?: RedirectStatus;
+    onUnexpectedRemoval?: "info" | "warning" | "error";
+};
+/**
+ * Minimal shape `buildRouteLock` reads from a content manifest entry. Only
+ * published entries should reach this function; the caller supplies the
+ * publish predicate so this module stays free of any runtime Core import.
+ */
+export type RouteLockSourceEntry = {
+    slug: string;
+    permalink: string;
+    frontmatter: Record<string, unknown>;
+    html: string;
+};
+export declare function hashContent(html: string): string;
+export declare function emptyRouteLock(): RouteLock;
+export declare function isRedirectStatus(value: unknown): value is RedirectStatus;
+/**
+ * Builds the current route lock from manifest entries. Entries are keyed by
+ * slug and only published entries are considered. Output is deterministic:
+ * route keys are sorted and redirects (always empty here) stay sorted.
+ */
+export declare function buildRouteLock(entries: readonly RouteLockSourceEntry[], isPublished: (frontmatter: Record<string, unknown>) => boolean): RouteLock;
+/**
+ * Parses a persisted lock. Returns `undefined` when the value is corrupt or
+ * uses an unknown format, so callers can fall back to an empty lock.
+ */
+export declare function parseRouteLock(value: unknown): RouteLock | undefined;
+/**
+ * Compares the previous lock with the current routes and returns the next lock
+ * plus any rename redirects discovered in this build.
+ *
+ * Detection precedence is strict and never fuzzy:
+ * 1. explicit identity (frontmatter `id`)
+ * 2. exact content hash (`sha256(html)`)
+ * 3. otherwise the route is treated as removed
+ */
+export declare function diffRoutes(previous: RouteLock, current: RouteLock, options?: DiffRoutesOptions): DiffRoutesResult;
+/**
+ * Merges redirect rules and collapses permanent chains: if `A -> B` is known
+ * and `B -> C` is added, the result keeps `A -> C` and `B -> C`. Output is
+ * sorted by `from` so the lock serializes deterministically.
+ */
+export declare function collapseRedirects(rules: readonly RedirectRule[]): RedirectRule[];
+export type ManifestRedirect = {
+    path: string;
+    status: RedirectStatus;
+    slug: string;
+};
+export type RedirectSink = {
+    redirects: Map<string, ManifestRedirect>;
+    byPermalink: ReadonlyMap<string, {
+        slug: string;
+    }>;
+};
+/**
+ * Adds rename redirects to `manifest.redirects` without ever overwriting an
+ * existing key (for example one declared through Permalink's `redirect_from`).
+ * Redirects whose source is a live permalink, or whose target is unknown, are
+ * skipped. Returns the rules that were actually applied.
+ */
+export declare function applyRouteRedirects(manifest: RedirectSink, rules: readonly RedirectRule[]): RedirectRule[];

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@riebeckite/plugin-rename",
+  "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"
+  },
+  "devDependencies": {
+    "tsx": "^4.22.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/rename"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Rename and move redirects for published Riebeckite notes.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "redirects",
+    "rename"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs",
+    "test": "node --import tsx --test \"test/*.test.ts\""
+  }
+}