feat: broaden IndexNow triggers to saves and permanent deletes

Adopt two hooks added in emdash 0.21.0:

- content:afterSave -> handleIndexNowPublished. Pings IndexNow whenever
  published content is saved, closing the gap where edits to an already-
  published page never notified search engines (afterPublish only fires
  on the draft->published transition). afterPublish and afterSave both
  route through this handler; a per-URL 60s debounce collapses the
  duplicate they fire at the publish moment and absorbs autosave bursts.
- content:afterDelete -> handleIndexNowDelete. Pings the dead URL on a
  permanent delete so engines recrawl and see the 404/410. The delete
  event carries only { id, collection } (no slug), so published saves
  cache an id->url mapping in KV that the delete handler resolves and
  clears. Trashing stays on the afterUnpublish path.

Extracted submitUrlToIndexNow from handleIndexNowTransition (now only
afterUnpublish). Added 9 tests; README + CHANGELOG updated.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jdevalk

CHANGELOG.md

@@ -7,9 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [0.12.0] - 2026-06-18
 
+### Added
+
+- **IndexNow now pings on edits to already-published pages.** The new `content:afterSave` hook fires on every save; the handler pings IndexNow whenever *published* content is saved. Previously only the draft→published transition (`content:afterPublish`) pinged, so editing a live page and re-saving never notified search engines. Both hooks route through the same handler; a per-URL debounce (60s, `PING_DEBOUNCE_MS`) collapses the duplicate the two fire at the publish moment and guards against autosave bursts.
+- **IndexNow now pings on permanent deletes.** The new `content:afterDelete` hook submits a permanently-deleted page's last-known URL to IndexNow so engines recrawl and see the 404/410. Because the delete event carries only `{ id, collection }` (no slug), published saves record an `id → url` mapping in plugin KV (`indexnow:urlmap:<collection>:<id>`) that the delete handler resolves and then clears. Trashing is treated as an unpublish and continues to flow through `content:afterUnpublish`.
+
 ### Changed
 
-- **`peerDependencies.emdash` bumped to `^0.21.0`.** Tracks the current EmDash release. The plugin API surface this plugin depends on — the `page:metadata`, `content:afterPublish`, and `content:afterUnpublish` hooks, plus the `read:content`, `page:inject`, and `network:fetch` capabilities — is unchanged from `0.6.0`, so no source changes were required. Verified against `emdash@0.21.0`: typecheck clean, all tests passing.
+- **`peerDependencies.emdash` bumped to `^0.21.0`.** Tracks the current EmDash release. The plugin API surface this plugin depends on — the `page:metadata`, `content:afterPublish`, and `content:afterUnpublish` hooks, plus the `read:content`, `page:inject`, and `network:fetch` capabilities — is unchanged from `0.6.0`, so the compatibility bump itself required no source changes. Verified against `emdash@0.21.0`: typecheck clean, all tests passing.
 - Internal plugin `version` strings in `src/index.ts` bumped to `0.12.0` to match the package version.
 
 ## [0.11.0] - 2026-04-21

README.md

@@ -34,7 +34,7 @@ An SEO plugin for [EmDash CMS](https://github.com/emdash-cms/emdash) that genera
 - **Schema map** *(experimental)* — exposes a list of every published URL backed by schema markup at the plugin's `schema/map` route, ready to be wired to a `/schemamap.xml` Astro endpoint for agent/crawler discovery
 - **Fuzzy Redirects** — admin tool that mines the core 404 log, ranks live URLs by path similarity (Levenshtein + token overlap + last-segment match), and lets you one-click create a 301 redirect for the best target. Catches moved slugs, typos in inbound links, and punctuation drift without having to write regex rules
 - **NLWeb `<link>` tag** — when the **NLWeb endpoint URL** setting is set, every rendered page carries `<link rel="nlweb" href="…">` advertising the site's conversational endpoint for agent discovery. Requires EmDash with [emdash-cms/emdash#523](https://github.com/emdash-cms/emdash/pull/523) merged; older versions drop the contribution silently
-- **IndexNow** — on publish/unpublish transitions, submits the affected URL to [IndexNow](https://www.indexnow.org) so Bing, Yandex, Seznam, Naver, and Yep recrawl immediately. Opt-in via a single toggle in the settings UI; the key is generated and persisted automatically on first use
+- **IndexNow** — on publish, on edits to an already-published page, on unpublish, and on permanent delete, submits the affected URL to [IndexNow](https://www.indexnow.org) so Bing, Yandex, Seznam, Naver, and Yep recrawl immediately. Opt-in via a single toggle in the settings UI; the key is generated and persisted automatically on first use
 - **Admin settings UI** — auto-generated from `settingsSchema` for configuring Person/Organization identity, social profiles, title separator, and default description
 
 ## Installation
@@ -129,9 +129,21 @@ URLs become `/fr-ca/…` and `/fr-fr/…`, and the emitted `hreflang` attributes
 ## IndexNow
 
 When enabled via the **IndexNow submission** setting, the plugin submits
-the canonical URL of any content item that transitions to or from
-published. A 32-character hex key is minted on first use and persisted in
-plugin KV.
+the canonical URL of a content item whenever it changes in a way search
+engines should re-crawl:
+
+- **Published, or edited while published** (`content:afterPublish` +
+  `content:afterSave`) — so both first publish and later edits to a live
+  page are picked up. A per-URL 60-second debounce collapses the duplicate
+  these two fire at the publish moment and absorbs autosave bursts.
+- **Unpublished** (`content:afterUnpublish`) — pings the now-dead URL so
+  engines see the 404/410.
+- **Permanently deleted** (`content:afterDelete`, only when the delete is
+  permanent rather than a trash) — the delete event carries no slug, so
+  published saves cache an `id → url` mapping in plugin KV that the delete
+  handler resolves, submits, and then clears.
+
+A 32-character hex key is minted on first use and persisted in plugin KV.
 
 The front-end Astro site must serve the key-verification file at
 `/<key>.txt`. Fetch the key from the plugin's `indexnow/key` route and

src/index.ts

@@ -4,6 +4,8 @@ import { metadataHandler } from "./metadata.js";
 import {
   getKeyFileBody,
   getOrCreateIndexNowKey,
+  handleIndexNowDelete,
+  handleIndexNowPublished,
   handleIndexNowTransition,
 } from "./indexnow.js";
 import { generateLlmsTxt } from "./llms.js";
@@ -37,13 +39,21 @@ export function createPlugin() {
         priority: 10,
       },
       "content:afterPublish": {
-        handler: handleIndexNowTransition,
+        handler: handleIndexNowPublished,
+        priority: 50,
+      },
+      "content:afterSave": {
+        handler: handleIndexNowPublished,
         priority: 50,
       },
       "content:afterUnpublish": {
         handler: handleIndexNowTransition,
         priority: 50,
       },
+      "content:afterDelete": {
+        handler: handleIndexNowDelete,
+        priority: 50,
+      },
     },
 
     routes: {

src/indexnow.ts

@@ -10,6 +10,36 @@ import { buildPageUrl } from "./urls.js";
 const KEY_KV = "indexnow:key";
 const ENABLED_KV = "settings:indexnowEnabled";
 
+/**
+ * Maps a content record's `id` to the canonical URL it was last published
+ * at: `indexnow:urlmap:<collection>:<id>` → absolute URL. We keep this
+ * because `content:afterDelete` carries only `{ id, collection }` — no
+ * slug — so the URL of a permanently-deleted item can't be rebuilt from
+ * the delete event alone. Written whenever published content is saved,
+ * read (and cleared) on permanent delete.
+ */
+const URLMAP_PREFIX = "indexnow:urlmap:";
+
+/**
+ * Records the epoch-ms of the last IndexNow submission per URL:
+ * `indexnow:lastping:<url>` → number. Used to debounce rapid autosaves of
+ * the same page so each editing burst pings at most once per window.
+ */
+const LASTPING_PREFIX = "indexnow:lastping:";
+
+/**
+ * Minimum gap between IndexNow submissions for the same URL. Editors
+ * autosave frequently; without this guard every keystroke-save of a live
+ * page would re-ping. A genuine edit in a later session (past the window)
+ * still pings. Tunable trade-off: longer = fewer pings but can swallow a
+ * real edit made shortly after publishing.
+ */
+const PING_DEBOUNCE_MS = 60_000;
+
+function urlMapKey(collection: string, id: string): string {
+  return `${URLMAP_PREFIX}${collection}:${id}`;
+}
+
 /**
  * Read or lazily generate the IndexNow key. The key is persisted in plugin
  * KV so subsequent submissions (and the key-file route exposed on the
@@ -83,10 +113,47 @@ async function urlForContent(
 }
 
 /**
- * Handler for `content:afterPublish` and `content:afterUnpublish`.
- * Submits the transitioned URL to IndexNow so participating engines
- * recrawl and pick up the new state (including 410/404 for unpublished
- * content). Fire-and-forget: never throws, logs errors on ctx.log.
+ * Submit a single URL to IndexNow for the current site. Resolves the host
+ * from `ctx.site.url`, mints/reuses the key, and logs each engine result.
+ * Returns silently when the site URL is missing or unparseable.
+ */
+async function submitUrlToIndexNow(ctx: PluginContext, url: string): Promise<void> {
+  const siteUrl = ctx.site.url;
+  if (!siteUrl) return;
+
+  let host: string;
+  try {
+    host = new URL(siteUrl).hostname;
+  } catch {
+    return;
+  }
+
+  const key = await getOrCreateIndexNowKey(ctx);
+
+  const results = await submitToIndexNow({ host, key, urls: [url] });
+
+  for (const r of results) {
+    if (r.ok) {
+      ctx.log.info("IndexNow: submitted", { url, status: r.status });
+    } else {
+      ctx.log.warn("IndexNow: submission failed", {
+        url,
+        status: r.status,
+        message: r.message,
+      });
+    }
+  }
+}
+
+/** Extract a string `id` from a content record, or null. */
+function contentId(content: Record<string, unknown>): string | null {
+  return typeof content.id === "string" && content.id ? content.id : null;
+}
+
+/**
+ * Handler for `content:afterUnpublish`. Submits the now-dead URL to
+ * IndexNow so participating engines recrawl and pick up the 404/410.
+ * Fire-and-forget: never throws, logs errors on ctx.log.
  */
 export async function handleIndexNowTransition(
   event: { content: Record<string, unknown>; collection: string },
@@ -101,37 +168,91 @@ export async function handleIndexNowTransition(
     const url = await urlForContent(event.content, event.collection, siteUrl);
     if (!url) return;
 
-    let host: string;
-    try {
-      host = new URL(siteUrl).hostname;
-    } catch {
-      return;
-    }
-
-    const key = await getOrCreateIndexNowKey(ctx);
-
-    const results = await submitToIndexNow({
-      host,
-      key,
-      urls: [url],
-    });
-
-    for (const r of results) {
-      if (r.ok) {
-        ctx.log.info("IndexNow: submitted", { url, status: r.status });
-      } else {
-        ctx.log.warn("IndexNow: submission failed", {
-          url,
-          status: r.status,
-          message: r.message,
-        });
-      }
-    }
+    await submitUrlToIndexNow(ctx, url);
   } catch (error) {
     ctx.log.warn("IndexNow: transition handler error", { error });
   }
 }
 
+/**
+ * Handler for `content:afterPublish` and `content:afterSave`. Pings
+ * IndexNow whenever *published* content is saved — this covers the
+ * publish transition (via `afterPublish`) and, crucially, edits to an
+ * already-published page (via `afterSave`), which `afterPublish` alone
+ * never sees. Non-published saves (drafts, autosaves of unpublished
+ * content) are ignored.
+ *
+ * Wiring both hooks here is deliberate: `afterPublish` guarantees the
+ * publish ping even if `afterSave` semantics differ, and the per-URL
+ * debounce (see `PING_DEBOUNCE_MS`) collapses the duplicate the two hooks
+ * fire at the publish moment into a single submission.
+ *
+ * Also records the `id → url` mapping so a later permanent delete can
+ * resolve the URL. Fire-and-forget: never throws.
+ */
+export async function handleIndexNowPublished(
+  event: { content: Record<string, unknown>; collection: string },
+  ctx: PluginContext,
+): Promise<void> {
+  try {
+    if (!(await isIndexNowEnabled(ctx))) return;
+
+    const status =
+      typeof event.content.status === "string" ? event.content.status : null;
+    if (status !== "published") return;
+
+    const siteUrl = ctx.site.url;
+    if (!siteUrl) return;
+
+    const url = await urlForContent(event.content, event.collection, siteUrl);
+    if (!url) return;
+
+    // Remember where this id lives so afterDelete can ping the dead URL.
+    const id = contentId(event.content);
+    if (id) await ctx.kv.set(urlMapKey(event.collection, id), url);
+
+    // Debounce rapid autosaves of the same URL.
+    const lastKey = `${LASTPING_PREFIX}${url}`;
+    const now = Date.now();
+    const last = await ctx.kv.get<number>(lastKey);
+    if (typeof last === "number" && now - last < PING_DEBOUNCE_MS) return;
+    await ctx.kv.set(lastKey, now);
+
+    await submitUrlToIndexNow(ctx, url);
+  } catch (error) {
+    ctx.log.warn("IndexNow: published handler error", { error });
+  }
+}
+
+/**
+ * Handler for `content:afterDelete`. On a *permanent* delete of content
+ * that was previously published, submits its last-known URL to IndexNow
+ * so engines recrawl and see the 404/410, then clears the cached mapping.
+ * Trashing (`permanent === false`) is an unpublish and is handled by
+ * `handleIndexNowTransition`; we skip it here. No-op when the id has no
+ * cached URL (never published, or already cleaned up).
+ */
+export async function handleIndexNowDelete(
+  event: { id: string; collection: string; permanent: boolean },
+  ctx: PluginContext,
+): Promise<void> {
+  try {
+    if (!event.permanent) return;
+    if (!(await isIndexNowEnabled(ctx))) return;
+
+    const mapKey = urlMapKey(event.collection, event.id);
+    const url = await ctx.kv.get<string>(mapKey);
+    if (typeof url !== "string" || !url) return;
+
+    await submitUrlToIndexNow(ctx, url);
+
+    await ctx.kv.delete(mapKey);
+    await ctx.kv.delete(`${LASTPING_PREFIX}${url}`);
+  } catch (error) {
+    ctx.log.warn("IndexNow: delete handler error", { error });
+  }
+}
+
 /** Returns the plain-text body to serve at `/<key>.txt`. */
 export async function getKeyFileBody(ctx: PluginContext): Promise<string> {
   const key = await getOrCreateIndexNowKey(ctx);