@plenary/next 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick DeLoughry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# @plenary/next
+
+Next.js glue for Plenary: turn entry webhooks into cache revalidation, and tag
+content fetches so dependent pages revalidate themselves.
+
+## Webhook revalidation (App Router)
+
+```ts
+// app/api/revalidate/route.ts
+import { createRevalidateHandler } from "@plenary/next";
+
+export const POST = createRevalidateHandler({
+  secret: process.env.PLENARY_WEBHOOK_SECRET!,
+});
+```
+
+In the Plenary console, add a webhook on each model pointing at
+`/api/revalidate`, subscribed to the entry events, with the secret in an
+`x-plenary-secret` custom header (marked secret). That's the whole setup: every
+event revalidates the entry's own URL, built from its folder path and slug
+(`/news` + `hello-world` → `/news/hello-world`).
+
+When a model's URLs don't mirror folder + slug, or other pages show its
+content, map it:
+
+```ts
+export const POST = createRevalidateHandler({
+  secret: process.env.PLENARY_WEBHOOK_SECRET!,
+  paths: {
+    "blog-post": ({ entry }) => ["/blog", `/blog/${entry.slug}`],
+    "global-settings": "/",           // fixed path or list also fine
+  },
+});
+```
+
+A mapped model replaces the default URL; compose with the exported `entryUrl`
+to keep it. Unmapped slugless entries (singletons) revalidate nothing. The
+`events` option narrows which entry events fire (default: all five —
+revalidation is idempotent, so over-firing beats a stale page). The console's
+**Test** button gets a dry run: a 200 reporting the paths it would have
+revalidated.
+
+The handler answers 401/405/400 for requests that will never succeed, so bad
+deliveries fail fast in the delivery log instead of retrying for seven hours.
+
+## Cache tags — no path map at all
+
+Path maps drift: add a page that renders a menu, forget to add it to the map,
+serve stale content. Tags don't. Give the content client a tagged fetch:
+
+```ts
+import { createClient } from "@plenary/client";
+import { createTaggedFetch } from "@plenary/next";
+
+export const plenary = createClient({
+  baseUrl: process.env.PLENARY_URL!,
+  siteKey: "main",
+  apiKey: process.env.PLENARY_API_KEY!,
+  locale: "en",
+  fetch: createTaggedFetch(),
+});
+```
+
+Every content read is now tagged `plenary:model:<key>` (and
+`plenary:entry:<slugOrId>` for single-entry reads). Enable tags on the handler:
+
+```ts
+export const POST = createRevalidateHandler({
+  secret: process.env.PLENARY_WEBHOOK_SECRET!,
+  tags: true,
+});
+```
+
+Each event then also revalidates the model and entry tags — every page that
+fetched that content regenerates, including the ones you forgot you built.
+
+## Pages Router
+
+```ts
+// pages/api/revalidate.ts
+import { createPagesRevalidateHandler } from "@plenary/next/pages";
+
+export default createPagesRevalidateHandler({
+  secret: process.env.PLENARY_WEBHOOK_SECRET!,
+});
+```
+
+Same options, built on `res.revalidate`. Cache tags are an App Router feature,
+so `tags` is ignored here.
+
+## Authentication
+
+Plenary does not sign webhook requests yet, so authentication is the shared
+secret above (constant-time compared; also accepted as a `?secret=` query
+parameter, names configurable via `secretHeader`/`secretQuery`). Payload
+parsing and verification live in `@plenary/client`
+(`parseWebhookRequest`, `verifyWebhookSecret`, and the payload types) for use
+outside Next.js; HMAC verification will land there when signing ships.

package/dist/chunk-BMLKEIKX.js

@@ -0,0 +1,69 @@
+// src/tags.ts
+function modelTag(modelKey) {
+  return `plenary:model:${modelKey}`;
+}
+function entryTag(slugOrId) {
+  return `plenary:entry:${slugOrId}`;
+}
+var CONTENT_URL = /\/api\/v1\/content\/([^/?#]+)(?:\/([^/?#]+))?/;
+function createTaggedFetch(baseFetch = fetch) {
+  return ((input, init) => {
+    const method = init?.method ?? "GET";
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const match = method === "GET" ? CONTENT_URL.exec(url) : null;
+    if (!match?.[1]) return baseFetch(input, init);
+    const tags = [modelTag(decodeURIComponent(match[1]))];
+    if (match[2]) tags.push(entryTag(decodeURIComponent(match[2])));
+    const next = init?.next;
+    const merged = {
+      ...init,
+      next: { ...next, tags: [...next?.tags ?? [], ...tags] }
+    };
+    return baseFetch(input, merged);
+  });
+}
+
+// src/resolve.ts
+import {
+  isEntryWebhookPayload,
+  WEBHOOK_TEST_EVENT
+} from "@plenary/client";
+function entryUrl(payload) {
+  const { slug, path } = payload.entry;
+  if (!slug) return null;
+  const dir = path && path !== "/" ? path : "";
+  return `${dir}/${slug}`;
+}
+function planRevalidation(payload, options) {
+  const none = { relevant: false, test: false, paths: [], tags: [] };
+  if (!isEntryWebhookPayload(payload)) return none;
+  const test = payload.event === WEBHOOK_TEST_EVENT;
+  if (!test && options.events && !options.events.includes(payload.event)) {
+    return none;
+  }
+  const modelKey = payload.model.key;
+  const mapped = modelKey === void 0 ? void 0 : options.paths?.[modelKey];
+  let paths;
+  if (mapped === void 0) {
+    paths = (options.entryUrl ?? entryUrl)(payload);
+  } else {
+    paths = typeof mapped === "function" ? mapped(payload) : mapped;
+  }
+  const pathList = paths == null ? [] : typeof paths === "string" ? [paths] : paths;
+  const tags = [];
+  if (options.tags) {
+    if (modelKey) tags.push(modelTag(modelKey));
+    tags.push(entryTag(payload.entry.id));
+    if (payload.entry.slug) tags.push(entryTag(payload.entry.slug));
+  }
+  return { relevant: true, test, paths: [...new Set(pathList)], tags };
+}
+
+export {
+  modelTag,
+  entryTag,
+  createTaggedFetch,
+  entryUrl,
+  planRevalidation
+};
+//# sourceMappingURL=chunk-BMLKEIKX.js.map

package/dist/chunk-BMLKEIKX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tags.ts","../src/resolve.ts"],"sourcesContent":["/**\n * Cache-tag conventions shared by the tagged fetch and the revalidation\n * handler. A page that fetches Plenary content through\n * {@link createTaggedFetch} is tagged with the model and entry it read, so the\n * webhook handler can revalidate every page that used a piece of content\n * without a path map.\n */\n\n/** Tag carried by every read of a model's content. */\nexport function modelTag(modelKey: string): string {\n  return `plenary:model:${modelKey}`;\n}\n\n/** Tag for one entry. The content API addresses entries by slug or UUID, and a\n * webhook payload carries both, so both spellings are revalidated. */\nexport function entryTag(slugOrId: string): string {\n  return `plenary:entry:${slugOrId}`;\n}\n\n/** Next.js extends `RequestInit` with `next`; declared locally so this package\n * compiles against the standard DOM lib. */\ninterface NextRequestInit extends RequestInit {\n  next?: { tags?: string[]; revalidate?: number | false };\n}\n\nconst CONTENT_URL = /\\/api\\/v1\\/content\\/([^/?#]+)(?:\\/([^/?#]+))?/;\n\n/**\n * Wraps a fetch implementation so Plenary content reads carry cache tags.\n * Pass it to `createClient`:\n *\n * ```ts\n * const plenary = createClient({ ...config, fetch: createTaggedFetch() });\n * ```\n *\n * GET requests to `/api/v1/content/{model}` are tagged with the model, and\n * `/api/v1/content/{model}/{slugOrId}` with the model and the entry. Anything\n * else passes through untouched.\n */\nexport function createTaggedFetch(baseFetch: typeof fetch = fetch): typeof fetch {\n  return ((input: RequestInfo | URL, init?: RequestInit) => {\n    const method = init?.method ?? \"GET\";\n    const url =\n      typeof input === \"string\" ? input : input instanceof URL ? input.href : input.url;\n    const match = method === \"GET\" ? CONTENT_URL.exec(url) : null;\n    if (!match?.[1]) return baseFetch(input, init);\n\n    const tags = [modelTag(decodeURIComponent(match[1]))];\n    if (match[2]) tags.push(entryTag(decodeURIComponent(match[2])));\n    const next = (init as NextRequestInit | undefined)?.next;\n    const merged: NextRequestInit = {\n      ...init,\n      next: { ...next, tags: [...(next?.tags ?? []), ...tags] },\n    };\n    return baseFetch(input, merged);\n  }) as typeof fetch;\n}\n","/**\n * The revalidation decision, shared by the App Router and Pages Router\n * handlers: which paths (and tags) one webhook payload maps to. Pure — the\n * handlers own the framework calls.\n */\n\nimport {\n  isEntryWebhookPayload,\n  WEBHOOK_TEST_EVENT,\n  type EntryWebhookEvent,\n  type EntryWebhookPayload,\n  type ParseWebhookOptions,\n  type WebhookPayload,\n} from \"@plenary/client\";\nimport { entryTag, modelTag } from \"./tags.js\";\n\n/** Paths for one model: a fixed path, a list, or a function of the payload.\n * A function may return `null`/`undefined` to revalidate nothing. */\nexport type RevalidatePaths =\n  | string\n  | string[]\n  | ((payload: EntryWebhookPayload) => string | string[] | null | undefined);\n\nexport interface RevalidateOptions extends ParseWebhookOptions {\n  /**\n   * Extra or overriding paths per model key. A mapped model replaces the\n   * default URL entirely — include `entryUrl(payload)` (exported) in the\n   * returned list to keep it.\n   */\n  paths?: Record<string, RevalidatePaths>;\n  /** Builds the default URL for unmapped models. Defaults to joining the\n   * entry's folder `path` and `slug`; return `null` to skip. */\n  entryUrl?: (payload: EntryWebhookPayload) => string | null | undefined;\n  /** Entry events that trigger revalidation. Default: all five — revalidation\n   * is idempotent and cheap, so over-firing beats a stale page. */\n  events?: EntryWebhookEvent[];\n  /** Also revalidate the `plenary:model:*` / `plenary:entry:*` cache tags used\n   * by `createTaggedFetch`. App Router only. */\n  tags?: boolean;\n}\n\n/** Default URL for an entry: folder path + slug (`/blog` + `spring-sale` →\n * `/blog/spring-sale`). Entries without a slug (singletons) get no default. */\nexport function entryUrl(payload: EntryWebhookPayload): string | null {\n  const { slug, path } = payload.entry;\n  if (!slug) return null;\n  const dir = path && path !== \"/\" ? path : \"\";\n  return `${dir}/${slug}`;\n}\n\nexport interface RevalidationPlan {\n  /** Whether this payload is one the handler acts on. */\n  relevant: boolean;\n  /** True for the console's Test button — report, don't revalidate. */\n  test: boolean;\n  paths: string[];\n  tags: string[];\n}\n\n/** Decides what one payload revalidates. */\nexport function planRevalidation(\n  payload: WebhookPayload,\n  options: RevalidateOptions,\n): RevalidationPlan {\n  const none = { relevant: false, test: false, paths: [], tags: [] };\n  if (!isEntryWebhookPayload(payload)) return none;\n\n  const test = payload.event === WEBHOOK_TEST_EVENT;\n  if (!test && options.events && !options.events.includes(payload.event as EntryWebhookEvent)) {\n    return none;\n  }\n\n  const modelKey = payload.model.key;\n  const mapped = modelKey === undefined ? undefined : options.paths?.[modelKey];\n  let paths: string | string[] | null | undefined;\n  if (mapped === undefined) {\n    paths = (options.entryUrl ?? entryUrl)(payload);\n  } else {\n    paths = typeof mapped === \"function\" ? mapped(payload) : mapped;\n  }\n  const pathList = paths == null ? [] : typeof paths === \"string\" ? [paths] : paths;\n\n  const tags: string[] = [];\n  if (options.tags) {\n    if (modelKey) tags.push(modelTag(modelKey));\n    tags.push(entryTag(payload.entry.id));\n    if (payload.entry.slug) tags.push(entryTag(payload.entry.slug));\n  }\n\n  return { relevant: true, test, paths: [...new Set(pathList)], tags };\n}\n"],"mappings":";AASO,SAAS,SAAS,UAA0B;AACjD,SAAO,iBAAiB,QAAQ;AAClC;AAIO,SAAS,SAAS,UAA0B;AACjD,SAAO,iBAAiB,QAAQ;AAClC;AAQA,IAAM,cAAc;AAcb,SAAS,kBAAkB,YAA0B,OAAqB;AAC/E,UAAQ,CAAC,OAA0B,SAAuB;AACxD,UAAM,SAAS,MAAM,UAAU;AAC/B,UAAM,MACJ,OAAO,UAAU,WAAW,QAAQ,iBAAiB,MAAM,MAAM,OAAO,MAAM;AAChF,UAAM,QAAQ,WAAW,QAAQ,YAAY,KAAK,GAAG,IAAI;AACzD,QAAI,CAAC,QAAQ,CAAC,EAAG,QAAO,UAAU,OAAO,IAAI;AAE7C,UAAM,OAAO,CAAC,SAAS,mBAAmB,MAAM,CAAC,CAAC,CAAC,CAAC;AACpD,QAAI,MAAM,CAAC,EAAG,MAAK,KAAK,SAAS,mBAAmB,MAAM,CAAC,CAAC,CAAC,CAAC;AAC9D,UAAM,OAAQ,MAAsC;AACpD,UAAM,SAA0B;AAAA,MAC9B,GAAG;AAAA,MACH,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,GAAI,MAAM,QAAQ,CAAC,GAAI,GAAG,IAAI,EAAE;AAAA,IAC1D;AACA,WAAO,UAAU,OAAO,MAAM;AAAA,EAChC;AACF;;;AClDA;AAAA,EACE;AAAA,EACA;AAAA,OAKK;AA8BA,SAAS,SAAS,SAA6C;AACpE,QAAM,EAAE,MAAM,KAAK,IAAI,QAAQ;AAC/B,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,MAAM,QAAQ,SAAS,MAAM,OAAO;AAC1C,SAAO,GAAG,GAAG,IAAI,IAAI;AACvB;AAYO,SAAS,iBACd,SACA,SACkB;AAClB,QAAM,OAAO,EAAE,UAAU,OAAO,MAAM,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC,EAAE;AACjE,MAAI,CAAC,sBAAsB,OAAO,EAAG,QAAO;AAE5C,QAAM,OAAO,QAAQ,UAAU;AAC/B,MAAI,CAAC,QAAQ,QAAQ,UAAU,CAAC,QAAQ,OAAO,SAAS,QAAQ,KAA0B,GAAG;AAC3F,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,QAAQ,MAAM;AAC/B,QAAM,SAAS,aAAa,SAAY,SAAY,QAAQ,QAAQ,QAAQ;AAC5E,MAAI;AACJ,MAAI,WAAW,QAAW;AACxB,aAAS,QAAQ,YAAY,UAAU,OAAO;AAAA,EAChD,OAAO;AACL,YAAQ,OAAO,WAAW,aAAa,OAAO,OAAO,IAAI;AAAA,EAC3D;AACA,QAAM,WAAW,SAAS,OAAO,CAAC,IAAI,OAAO,UAAU,WAAW,CAAC,KAAK,IAAI;AAE5E,QAAM,OAAiB,CAAC;AACxB,MAAI,QAAQ,MAAM;AAChB,QAAI,SAAU,MAAK,KAAK,SAAS,QAAQ,CAAC;AAC1C,SAAK,KAAK,SAAS,QAAQ,MAAM,EAAE,CAAC;AACpC,QAAI,QAAQ,MAAM,KAAM,MAAK,KAAK,SAAS,QAAQ,MAAM,IAAI,CAAC;AAAA,EAChE;AAEA,SAAO,EAAE,UAAU,MAAM,MAAM,OAAO,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,GAAG,KAAK;AACrE;","names":[]}

package/dist/index.cjs

@@ -0,0 +1,129 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRevalidateHandler: () => createRevalidateHandler,
+  createTaggedFetch: () => createTaggedFetch,
+  entryTag: () => entryTag,
+  entryUrl: () => entryUrl,
+  modelTag: () => modelTag,
+  planRevalidation: () => planRevalidation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/revalidate.ts
+var import_cache = require("next/cache");
+var import_client2 = require("@plenary/client");
+
+// src/resolve.ts
+var import_client = require("@plenary/client");
+
+// src/tags.ts
+function modelTag(modelKey) {
+  return `plenary:model:${modelKey}`;
+}
+function entryTag(slugOrId) {
+  return `plenary:entry:${slugOrId}`;
+}
+var CONTENT_URL = /\/api\/v1\/content\/([^/?#]+)(?:\/([^/?#]+))?/;
+function createTaggedFetch(baseFetch = fetch) {
+  return ((input, init) => {
+    const method = init?.method ?? "GET";
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const match = method === "GET" ? CONTENT_URL.exec(url) : null;
+    if (!match?.[1]) return baseFetch(input, init);
+    const tags = [modelTag(decodeURIComponent(match[1]))];
+    if (match[2]) tags.push(entryTag(decodeURIComponent(match[2])));
+    const next = init?.next;
+    const merged = {
+      ...init,
+      next: { ...next, tags: [...next?.tags ?? [], ...tags] }
+    };
+    return baseFetch(input, merged);
+  });
+}
+
+// src/resolve.ts
+function entryUrl(payload) {
+  const { slug, path } = payload.entry;
+  if (!slug) return null;
+  const dir = path && path !== "/" ? path : "";
+  return `${dir}/${slug}`;
+}
+function planRevalidation(payload, options) {
+  const none = { relevant: false, test: false, paths: [], tags: [] };
+  if (!(0, import_client.isEntryWebhookPayload)(payload)) return none;
+  const test = payload.event === import_client.WEBHOOK_TEST_EVENT;
+  if (!test && options.events && !options.events.includes(payload.event)) {
+    return none;
+  }
+  const modelKey = payload.model.key;
+  const mapped = modelKey === void 0 ? void 0 : options.paths?.[modelKey];
+  let paths;
+  if (mapped === void 0) {
+    paths = (options.entryUrl ?? entryUrl)(payload);
+  } else {
+    paths = typeof mapped === "function" ? mapped(payload) : mapped;
+  }
+  const pathList = paths == null ? [] : typeof paths === "string" ? [paths] : paths;
+  const tags = [];
+  if (options.tags) {
+    if (modelKey) tags.push(modelTag(modelKey));
+    tags.push(entryTag(payload.entry.id));
+    if (payload.entry.slug) tags.push(entryTag(payload.entry.slug));
+  }
+  return { relevant: true, test, paths: [...new Set(pathList)], tags };
+}
+
+// src/revalidate.ts
+function createRevalidateHandler(options) {
+  return async (request) => {
+    let payload;
+    try {
+      payload = await (0, import_client2.parseWebhookRequest)(request, options);
+    } catch (err) {
+      if (err instanceof import_client2.PlenaryWebhookError) {
+        return Response.json({ message: err.message }, { status: err.status });
+      }
+      throw err;
+    }
+    const plan = planRevalidation(payload, options);
+    if (!plan.relevant) {
+      return Response.json({ revalidated: false, ignored: payload.event });
+    }
+    if (plan.test) {
+      return Response.json({ test: true, paths: plan.paths, tags: plan.tags });
+    }
+    for (const path of plan.paths) (0, import_cache.revalidatePath)(path);
+    for (const tag of plan.tags) (0, import_cache.revalidateTag)(tag);
+    return Response.json({ revalidated: true, paths: plan.paths, tags: plan.tags });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRevalidateHandler,
+  createTaggedFetch,
+  entryTag,
+  entryUrl,
+  modelTag,
+  planRevalidation
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/revalidate.ts","../src/resolve.ts","../src/tags.ts"],"sourcesContent":["/**\n * @plenary/next — Next.js glue for Plenary: webhook-driven cache revalidation\n * and cache-tagged content fetching. The Pages Router handler lives in\n * `@plenary/next/pages` so this entry stays free of `next` type imports.\n */\n\nexport { createRevalidateHandler } from \"./revalidate.js\";\nexport {\n  entryUrl,\n  planRevalidation,\n  type RevalidateOptions,\n  type RevalidatePaths,\n  type RevalidationPlan,\n} from \"./resolve.js\";\nexport { createTaggedFetch, modelTag, entryTag } from \"./tags.js\";\n","import { revalidatePath, revalidateTag } from \"next/cache\";\nimport { parseWebhookRequest, PlenaryWebhookError } from \"@plenary/client\";\nimport { planRevalidation, type RevalidateOptions } from \"./resolve.js\";\n\n/**\n * Builds an App Router route handler that turns Plenary entry webhooks into\n * `revalidatePath`/`revalidateTag` calls.\n *\n * ```ts\n * // app/api/revalidate/route.ts\n * export const POST = createRevalidateHandler({\n *   secret: process.env.PLENARY_WEBHOOK_SECRET!,\n * });\n * ```\n *\n * With no `paths` map, each event revalidates the entry's own URL (folder\n * path + slug). Point the webhook at the route, subscribed to the entry\n * events, with the secret in an `x-plenary-secret` header.\n *\n * The console's Test button gets a dry run: a 200 reporting what would have\n * been revalidated, without touching the cache.\n */\nexport function createRevalidateHandler(\n  options: RevalidateOptions,\n): (request: Request) => Promise<Response> {\n  return async (request) => {\n    let payload;\n    try {\n      payload = await parseWebhookRequest(request, options);\n    } catch (err) {\n      if (err instanceof PlenaryWebhookError) {\n        return Response.json({ message: err.message }, { status: err.status });\n      }\n      throw err;\n    }\n\n    const plan = planRevalidation(payload, options);\n    if (!plan.relevant) {\n      return Response.json({ revalidated: false, ignored: payload.event });\n    }\n    if (plan.test) {\n      return Response.json({ test: true, paths: plan.paths, tags: plan.tags });\n    }\n    for (const path of plan.paths) revalidatePath(path);\n    for (const tag of plan.tags) revalidateTag(tag);\n    return Response.json({ revalidated: true, paths: plan.paths, tags: plan.tags });\n  };\n}\n","/**\n * The revalidation decision, shared by the App Router and Pages Router\n * handlers: which paths (and tags) one webhook payload maps to. Pure — the\n * handlers own the framework calls.\n */\n\nimport {\n  isEntryWebhookPayload,\n  WEBHOOK_TEST_EVENT,\n  type EntryWebhookEvent,\n  type EntryWebhookPayload,\n  type ParseWebhookOptions,\n  type WebhookPayload,\n} from \"@plenary/client\";\nimport { entryTag, modelTag } from \"./tags.js\";\n\n/** Paths for one model: a fixed path, a list, or a function of the payload.\n * A function may return `null`/`undefined` to revalidate nothing. */\nexport type RevalidatePaths =\n  | string\n  | string[]\n  | ((payload: EntryWebhookPayload) => string | string[] | null | undefined);\n\nexport interface RevalidateOptions extends ParseWebhookOptions {\n  /**\n   * Extra or overriding paths per model key. A mapped model replaces the\n   * default URL entirely — include `entryUrl(payload)` (exported) in the\n   * returned list to keep it.\n   */\n  paths?: Record<string, RevalidatePaths>;\n  /** Builds the default URL for unmapped models. Defaults to joining the\n   * entry's folder `path` and `slug`; return `null` to skip. */\n  entryUrl?: (payload: EntryWebhookPayload) => string | null | undefined;\n  /** Entry events that trigger revalidation. Default: all five — revalidation\n   * is idempotent and cheap, so over-firing beats a stale page. */\n  events?: EntryWebhookEvent[];\n  /** Also revalidate the `plenary:model:*` / `plenary:entry:*` cache tags used\n   * by `createTaggedFetch`. App Router only. */\n  tags?: boolean;\n}\n\n/** Default URL for an entry: folder path + slug (`/blog` + `spring-sale` →\n * `/blog/spring-sale`). Entries without a slug (singletons) get no default. */\nexport function entryUrl(payload: EntryWebhookPayload): string | null {\n  const { slug, path } = payload.entry;\n  if (!slug) return null;\n  const dir = path && path !== \"/\" ? path : \"\";\n  return `${dir}/${slug}`;\n}\n\nexport interface RevalidationPlan {\n  /** Whether this payload is one the handler acts on. */\n  relevant: boolean;\n  /** True for the console's Test button — report, don't revalidate. */\n  test: boolean;\n  paths: string[];\n  tags: string[];\n}\n\n/** Decides what one payload revalidates. */\nexport function planRevalidation(\n  payload: WebhookPayload,\n  options: RevalidateOptions,\n): RevalidationPlan {\n  const none = { relevant: false, test: false, paths: [], tags: [] };\n  if (!isEntryWebhookPayload(payload)) return none;\n\n  const test = payload.event === WEBHOOK_TEST_EVENT;\n  if (!test && options.events && !options.events.includes(payload.event as EntryWebhookEvent)) {\n    return none;\n  }\n\n  const modelKey = payload.model.key;\n  const mapped = modelKey === undefined ? undefined : options.paths?.[modelKey];\n  let paths: string | string[] | null | undefined;\n  if (mapped === undefined) {\n    paths = (options.entryUrl ?? entryUrl)(payload);\n  } else {\n    paths = typeof mapped === \"function\" ? mapped(payload) : mapped;\n  }\n  const pathList = paths == null ? [] : typeof paths === \"string\" ? [paths] : paths;\n\n  const tags: string[] = [];\n  if (options.tags) {\n    if (modelKey) tags.push(modelTag(modelKey));\n    tags.push(entryTag(payload.entry.id));\n    if (payload.entry.slug) tags.push(entryTag(payload.entry.slug));\n  }\n\n  return { relevant: true, test, paths: [...new Set(pathList)], tags };\n}\n","/**\n * Cache-tag conventions shared by the tagged fetch and the revalidation\n * handler. A page that fetches Plenary content through\n * {@link createTaggedFetch} is tagged with the model and entry it read, so the\n * webhook handler can revalidate every page that used a piece of content\n * without a path map.\n */\n\n/** Tag carried by every read of a model's content. */\nexport function modelTag(modelKey: string): string {\n  return `plenary:model:${modelKey}`;\n}\n\n/** Tag for one entry. The content API addresses entries by slug or UUID, and a\n * webhook payload carries both, so both spellings are revalidated. */\nexport function entryTag(slugOrId: string): string {\n  return `plenary:entry:${slugOrId}`;\n}\n\n/** Next.js extends `RequestInit` with `next`; declared locally so this package\n * compiles against the standard DOM lib. */\ninterface NextRequestInit extends RequestInit {\n  next?: { tags?: string[]; revalidate?: number | false };\n}\n\nconst CONTENT_URL = /\\/api\\/v1\\/content\\/([^/?#]+)(?:\\/([^/?#]+))?/;\n\n/**\n * Wraps a fetch implementation so Plenary content reads carry cache tags.\n * Pass it to `createClient`:\n *\n * ```ts\n * const plenary = createClient({ ...config, fetch: createTaggedFetch() });\n * ```\n *\n * GET requests to `/api/v1/content/{model}` are tagged with the model, and\n * `/api/v1/content/{model}/{slugOrId}` with the model and the entry. Anything\n * else passes through untouched.\n */\nexport function createTaggedFetch(baseFetch: typeof fetch = fetch): typeof fetch {\n  return ((input: RequestInfo | URL, init?: RequestInit) => {\n    const method = init?.method ?? \"GET\";\n    const url =\n      typeof input === \"string\" ? input : input instanceof URL ? input.href : input.url;\n    const match = method === \"GET\" ? CONTENT_URL.exec(url) : null;\n    if (!match?.[1]) return baseFetch(input, init);\n\n    const tags = [modelTag(decodeURIComponent(match[1]))];\n    if (match[2]) tags.push(entryTag(decodeURIComponent(match[2])));\n    const next = (init as NextRequestInit | undefined)?.next;\n    const merged: NextRequestInit = {\n      ...init,\n      next: { ...next, tags: [...(next?.tags ?? []), ...tags] },\n    };\n    return baseFetch(input, merged);\n  }) as typeof fetch;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAA8C;AAC9C,IAAAA,iBAAyD;;;ACKzD,oBAOO;;;ACJA,SAAS,SAAS,UAA0B;AACjD,SAAO,iBAAiB,QAAQ;AAClC;AAIO,SAAS,SAAS,UAA0B;AACjD,SAAO,iBAAiB,QAAQ;AAClC;AAQA,IAAM,cAAc;AAcb,SAAS,kBAAkB,YAA0B,OAAqB;AAC/E,UAAQ,CAAC,OAA0B,SAAuB;AACxD,UAAM,SAAS,MAAM,UAAU;AAC/B,UAAM,MACJ,OAAO,UAAU,WAAW,QAAQ,iBAAiB,MAAM,MAAM,OAAO,MAAM;AAChF,UAAM,QAAQ,WAAW,QAAQ,YAAY,KAAK,GAAG,IAAI;AACzD,QAAI,CAAC,QAAQ,CAAC,EAAG,QAAO,UAAU,OAAO,IAAI;AAE7C,UAAM,OAAO,CAAC,SAAS,mBAAmB,MAAM,CAAC,CAAC,CAAC,CAAC;AACpD,QAAI,MAAM,CAAC,EAAG,MAAK,KAAK,SAAS,mBAAmB,MAAM,CAAC,CAAC,CAAC,CAAC;AAC9D,UAAM,OAAQ,MAAsC;AACpD,UAAM,SAA0B;AAAA,MAC9B,GAAG;AAAA,MACH,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,GAAI,MAAM,QAAQ,CAAC,GAAI,GAAG,IAAI,EAAE;AAAA,IAC1D;AACA,WAAO,UAAU,OAAO,MAAM;AAAA,EAChC;AACF;;;ADbO,SAAS,SAAS,SAA6C;AACpE,QAAM,EAAE,MAAM,KAAK,IAAI,QAAQ;AAC/B,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,MAAM,QAAQ,SAAS,MAAM,OAAO;AAC1C,SAAO,GAAG,GAAG,IAAI,IAAI;AACvB;AAYO,SAAS,iBACd,SACA,SACkB;AAClB,QAAM,OAAO,EAAE,UAAU,OAAO,MAAM,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC,EAAE;AACjE,MAAI,KAAC,qCAAsB,OAAO,EAAG,QAAO;AAE5C,QAAM,OAAO,QAAQ,UAAU;AAC/B,MAAI,CAAC,QAAQ,QAAQ,UAAU,CAAC,QAAQ,OAAO,SAAS,QAAQ,KAA0B,GAAG;AAC3F,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,QAAQ,MAAM;AAC/B,QAAM,SAAS,aAAa,SAAY,SAAY,QAAQ,QAAQ,QAAQ;AAC5E,MAAI;AACJ,MAAI,WAAW,QAAW;AACxB,aAAS,QAAQ,YAAY,UAAU,OAAO;AAAA,EAChD,OAAO;AACL,YAAQ,OAAO,WAAW,aAAa,OAAO,OAAO,IAAI;AAAA,EAC3D;AACA,QAAM,WAAW,SAAS,OAAO,CAAC,IAAI,OAAO,UAAU,WAAW,CAAC,KAAK,IAAI;AAE5E,QAAM,OAAiB,CAAC;AACxB,MAAI,QAAQ,MAAM;AAChB,QAAI,SAAU,MAAK,KAAK,SAAS,QAAQ,CAAC;AAC1C,SAAK,KAAK,SAAS,QAAQ,MAAM,EAAE,CAAC;AACpC,QAAI,QAAQ,MAAM,KAAM,MAAK,KAAK,SAAS,QAAQ,MAAM,IAAI,CAAC;AAAA,EAChE;AAEA,SAAO,EAAE,UAAU,MAAM,MAAM,OAAO,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,GAAG,KAAK;AACrE;;;ADpEO,SAAS,wBACd,SACyC;AACzC,SAAO,OAAO,YAAY;AACxB,QAAI;AACJ,QAAI;AACF,gBAAU,UAAM,oCAAoB,SAAS,OAAO;AAAA,IACtD,SAAS,KAAK;AACZ,UAAI,eAAe,oCAAqB;AACtC,eAAO,SAAS,KAAK,EAAE,SAAS,IAAI,QAAQ,GAAG,EAAE,QAAQ,IAAI,OAAO,CAAC;AAAA,MACvE;AACA,YAAM;AAAA,IACR;AAEA,UAAM,OAAO,iBAAiB,SAAS,OAAO;AAC9C,QAAI,CAAC,KAAK,UAAU;AAClB,aAAO,SAAS,KAAK,EAAE,aAAa,OAAO,SAAS,QAAQ,MAAM,CAAC;AAAA,IACrE;AACA,QAAI,KAAK,MAAM;AACb,aAAO,SAAS,KAAK,EAAE,MAAM,MAAM,OAAO,KAAK,OAAO,MAAM,KAAK,KAAK,CAAC;AAAA,IACzE;AACA,eAAW,QAAQ,KAAK,MAAO,kCAAe,IAAI;AAClD,eAAW,OAAO,KAAK,KAAM,iCAAc,GAAG;AAC9C,WAAO,SAAS,KAAK,EAAE,aAAa,MAAM,OAAO,KAAK,OAAO,MAAM,KAAK,KAAK,CAAC;AAAA,EAChF;AACF;","names":["import_client"]}

package/dist/index.d.cts

@@ -0,0 +1,51 @@
+import { R as RevalidateOptions } from './resolve-DzNy1GAi.cjs';
+export { a as RevalidatePaths, b as RevalidationPlan, e as entryUrl, p as planRevalidation } from './resolve-DzNy1GAi.cjs';
+import '@plenary/client';
+
+/**
+ * Builds an App Router route handler that turns Plenary entry webhooks into
+ * `revalidatePath`/`revalidateTag` calls.
+ *
+ * ```ts
+ * // app/api/revalidate/route.ts
+ * export const POST = createRevalidateHandler({
+ *   secret: process.env.PLENARY_WEBHOOK_SECRET!,
+ * });
+ * ```
+ *
+ * With no `paths` map, each event revalidates the entry's own URL (folder
+ * path + slug). Point the webhook at the route, subscribed to the entry
+ * events, with the secret in an `x-plenary-secret` header.
+ *
+ * The console's Test button gets a dry run: a 200 reporting what would have
+ * been revalidated, without touching the cache.
+ */
+declare function createRevalidateHandler(options: RevalidateOptions): (request: Request) => Promise<Response>;
+
+/**
+ * Cache-tag conventions shared by the tagged fetch and the revalidation
+ * handler. A page that fetches Plenary content through
+ * {@link createTaggedFetch} is tagged with the model and entry it read, so the
+ * webhook handler can revalidate every page that used a piece of content
+ * without a path map.
+ */
+/** Tag carried by every read of a model's content. */
+declare function modelTag(modelKey: string): string;
+/** Tag for one entry. The content API addresses entries by slug or UUID, and a
+ * webhook payload carries both, so both spellings are revalidated. */
+declare function entryTag(slugOrId: string): string;
+/**
+ * Wraps a fetch implementation so Plenary content reads carry cache tags.
+ * Pass it to `createClient`:
+ *
+ * ```ts
+ * const plenary = createClient({ ...config, fetch: createTaggedFetch() });
+ * ```
+ *
+ * GET requests to `/api/v1/content/{model}` are tagged with the model, and
+ * `/api/v1/content/{model}/{slugOrId}` with the model and the entry. Anything
+ * else passes through untouched.
+ */
+declare function createTaggedFetch(baseFetch?: typeof fetch): typeof fetch;
+
+export { RevalidateOptions, createRevalidateHandler, createTaggedFetch, entryTag, modelTag };

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { R as RevalidateOptions } from './resolve-DzNy1GAi.js';
+export { a as RevalidatePaths, b as RevalidationPlan, e as entryUrl, p as planRevalidation } from './resolve-DzNy1GAi.js';
+import '@plenary/client';
+
+/**
+ * Builds an App Router route handler that turns Plenary entry webhooks into
+ * `revalidatePath`/`revalidateTag` calls.
+ *
+ * ```ts
+ * // app/api/revalidate/route.ts
+ * export const POST = createRevalidateHandler({
+ *   secret: process.env.PLENARY_WEBHOOK_SECRET!,
+ * });
+ * ```
+ *
+ * With no `paths` map, each event revalidates the entry's own URL (folder
+ * path + slug). Point the webhook at the route, subscribed to the entry
+ * events, with the secret in an `x-plenary-secret` header.
+ *
+ * The console's Test button gets a dry run: a 200 reporting what would have
+ * been revalidated, without touching the cache.
+ */
+declare function createRevalidateHandler(options: RevalidateOptions): (request: Request) => Promise<Response>;
+
+/**
+ * Cache-tag conventions shared by the tagged fetch and the revalidation
+ * handler. A page that fetches Plenary content through
+ * {@link createTaggedFetch} is tagged with the model and entry it read, so the
+ * webhook handler can revalidate every page that used a piece of content
+ * without a path map.
+ */
+/** Tag carried by every read of a model's content. */
+declare function modelTag(modelKey: string): string;
+/** Tag for one entry. The content API addresses entries by slug or UUID, and a
+ * webhook payload carries both, so both spellings are revalidated. */
+declare function entryTag(slugOrId: string): string;
+/**
+ * Wraps a fetch implementation so Plenary content reads carry cache tags.
+ * Pass it to `createClient`:
+ *
+ * ```ts
+ * const plenary = createClient({ ...config, fetch: createTaggedFetch() });
+ * ```
+ *
+ * GET requests to `/api/v1/content/{model}` are tagged with the model, and
+ * `/api/v1/content/{model}/{slugOrId}` with the model and the entry. Anything
+ * else passes through untouched.
+ */
+declare function createTaggedFetch(baseFetch?: typeof fetch): typeof fetch;
+
+export { RevalidateOptions, createRevalidateHandler, createTaggedFetch, entryTag, modelTag };

package/dist/index.js

@@ -0,0 +1,43 @@
+import {
+  createTaggedFetch,
+  entryTag,
+  entryUrl,
+  modelTag,
+  planRevalidation
+} from "./chunk-BMLKEIKX.js";
+
+// src/revalidate.ts
+import { revalidatePath, revalidateTag } from "next/cache";
+import { parseWebhookRequest, PlenaryWebhookError } from "@plenary/client";
+function createRevalidateHandler(options) {
+  return async (request) => {
+    let payload;
+    try {
+      payload = await parseWebhookRequest(request, options);
+    } catch (err) {
+      if (err instanceof PlenaryWebhookError) {
+        return Response.json({ message: err.message }, { status: err.status });
+      }
+      throw err;
+    }
+    const plan = planRevalidation(payload, options);
+    if (!plan.relevant) {
+      return Response.json({ revalidated: false, ignored: payload.event });
+    }
+    if (plan.test) {
+      return Response.json({ test: true, paths: plan.paths, tags: plan.tags });
+    }
+    for (const path of plan.paths) revalidatePath(path);
+    for (const tag of plan.tags) revalidateTag(tag);
+    return Response.json({ revalidated: true, paths: plan.paths, tags: plan.tags });
+  };
+}
+export {
+  createRevalidateHandler,
+  createTaggedFetch,
+  entryTag,
+  entryUrl,
+  modelTag,
+  planRevalidation
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/revalidate.ts"],"sourcesContent":["import { revalidatePath, revalidateTag } from \"next/cache\";\nimport { parseWebhookRequest, PlenaryWebhookError } from \"@plenary/client\";\nimport { planRevalidation, type RevalidateOptions } from \"./resolve.js\";\n\n/**\n * Builds an App Router route handler that turns Plenary entry webhooks into\n * `revalidatePath`/`revalidateTag` calls.\n *\n * ```ts\n * // app/api/revalidate/route.ts\n * export const POST = createRevalidateHandler({\n *   secret: process.env.PLENARY_WEBHOOK_SECRET!,\n * });\n * ```\n *\n * With no `paths` map, each event revalidates the entry's own URL (folder\n * path + slug). Point the webhook at the route, subscribed to the entry\n * events, with the secret in an `x-plenary-secret` header.\n *\n * The console's Test button gets a dry run: a 200 reporting what would have\n * been revalidated, without touching the cache.\n */\nexport function createRevalidateHandler(\n  options: RevalidateOptions,\n): (request: Request) => Promise<Response> {\n  return async (request) => {\n    let payload;\n    try {\n      payload = await parseWebhookRequest(request, options);\n    } catch (err) {\n      if (err instanceof PlenaryWebhookError) {\n        return Response.json({ message: err.message }, { status: err.status });\n      }\n      throw err;\n    }\n\n    const plan = planRevalidation(payload, options);\n    if (!plan.relevant) {\n      return Response.json({ revalidated: false, ignored: payload.event });\n    }\n    if (plan.test) {\n      return Response.json({ test: true, paths: plan.paths, tags: plan.tags });\n    }\n    for (const path of plan.paths) revalidatePath(path);\n    for (const tag of plan.tags) revalidateTag(tag);\n    return Response.json({ revalidated: true, paths: plan.paths, tags: plan.tags });\n  };\n}\n"],"mappings":";;;;;;;;;AAAA,SAAS,gBAAgB,qBAAqB;AAC9C,SAAS,qBAAqB,2BAA2B;AAqBlD,SAAS,wBACd,SACyC;AACzC,SAAO,OAAO,YAAY;AACxB,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,oBAAoB,SAAS,OAAO;AAAA,IACtD,SAAS,KAAK;AACZ,UAAI,eAAe,qBAAqB;AACtC,eAAO,SAAS,KAAK,EAAE,SAAS,IAAI,QAAQ,GAAG,EAAE,QAAQ,IAAI,OAAO,CAAC;AAAA,MACvE;AACA,YAAM;AAAA,IACR;AAEA,UAAM,OAAO,iBAAiB,SAAS,OAAO;AAC9C,QAAI,CAAC,KAAK,UAAU;AAClB,aAAO,SAAS,KAAK,EAAE,aAAa,OAAO,SAAS,QAAQ,MAAM,CAAC;AAAA,IACrE;AACA,QAAI,KAAK,MAAM;AACb,aAAO,SAAS,KAAK,EAAE,MAAM,MAAM,OAAO,KAAK,OAAO,MAAM,KAAK,KAAK,CAAC;AAAA,IACzE;AACA,eAAW,QAAQ,KAAK,MAAO,gBAAe,IAAI;AAClD,eAAW,OAAO,KAAK,KAAM,eAAc,GAAG;AAC9C,WAAO,SAAS,KAAK,EAAE,aAAa,MAAM,OAAO,KAAK,OAAO,MAAM,KAAK,KAAK,CAAC;AAAA,EAChF;AACF;","names":[]}

package/dist/pages.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pages.ts
+var pages_exports = {};
+__export(pages_exports, {
+  createPagesRevalidateHandler: () => createPagesRevalidateHandler
+});
+module.exports = __toCommonJS(pages_exports);
+var import_client2 = require("@plenary/client");
+
+// src/resolve.ts
+var import_client = require("@plenary/client");
+
+// src/tags.ts
+function modelTag(modelKey) {
+  return `plenary:model:${modelKey}`;
+}
+function entryTag(slugOrId) {
+  return `plenary:entry:${slugOrId}`;
+}
+
+// src/resolve.ts
+function entryUrl(payload) {
+  const { slug, path } = payload.entry;
+  if (!slug) return null;
+  const dir = path && path !== "/" ? path : "";
+  return `${dir}/${slug}`;
+}
+function planRevalidation(payload, options) {
+  const none = { relevant: false, test: false, paths: [], tags: [] };
+  if (!(0, import_client.isEntryWebhookPayload)(payload)) return none;
+  const test = payload.event === import_client.WEBHOOK_TEST_EVENT;
+  if (!test && options.events && !options.events.includes(payload.event)) {
+    return none;
+  }
+  const modelKey = payload.model.key;
+  const mapped = modelKey === void 0 ? void 0 : options.paths?.[modelKey];
+  let paths;
+  if (mapped === void 0) {
+    paths = (options.entryUrl ?? entryUrl)(payload);
+  } else {
+    paths = typeof mapped === "function" ? mapped(payload) : mapped;
+  }
+  const pathList = paths == null ? [] : typeof paths === "string" ? [paths] : paths;
+  const tags = [];
+  if (options.tags) {
+    if (modelKey) tags.push(modelTag(modelKey));
+    tags.push(entryTag(payload.entry.id));
+    if (payload.entry.slug) tags.push(entryTag(payload.entry.slug));
+  }
+  return { relevant: true, test, paths: [...new Set(pathList)], tags };
+}
+
+// src/pages.ts
+function createPagesRevalidateHandler(options) {
+  const header = options.secretHeader ?? "x-plenary-secret";
+  const query = options.secretQuery ?? "secret";
+  return async (req, res) => {
+    if (req.method !== "POST") {
+      res.status(405).json({ message: "Method not allowed" });
+      return;
+    }
+    const fromHeader = req.headers[header];
+    const fromQuery = req.query[query];
+    const provided = (Array.isArray(fromHeader) ? fromHeader[0] : fromHeader) ?? (Array.isArray(fromQuery) ? fromQuery[0] : fromQuery);
+    if (!(0, import_client2.verifyWebhookSecret)(provided, options.secret)) {
+      res.status(401).json({ message: "Invalid webhook secret" });
+      return;
+    }
+    let payload;
+    try {
+      payload = (0, import_client2.parseWebhookPayload)(req.body);
+    } catch (err) {
+      if (err instanceof import_client2.PlenaryWebhookError) {
+        res.status(err.status).json({ message: err.message });
+        return;
+      }
+      throw err;
+    }
+    const plan = planRevalidation(payload, options);
+    if (!plan.relevant) {
+      res.json({ revalidated: false, ignored: payload.event });
+      return;
+    }
+    if (plan.test) {
+      res.json({ test: true, paths: plan.paths });
+      return;
+    }
+    await Promise.all(plan.paths.map((p) => res.revalidate(p)));
+    res.json({ revalidated: true, paths: plan.paths });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPagesRevalidateHandler
+});
+//# sourceMappingURL=pages.cjs.map

package/dist/pages.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pages.ts","../src/resolve.ts","../src/tags.ts"],"sourcesContent":["import type { NextApiRequest, NextApiResponse } from \"next\";\nimport {\n  parseWebhookPayload,\n  verifyWebhookSecret,\n  PlenaryWebhookError,\n} from \"@plenary/client\";\nimport { planRevalidation, type RevalidateOptions } from \"./resolve.js\";\n\n/**\n * The Pages Router counterpart of `createRevalidateHandler`, built on\n * `res.revalidate`.\n *\n * ```ts\n * // pages/api/revalidate.ts\n * export default createPagesRevalidateHandler({\n *   secret: process.env.PLENARY_WEBHOOK_SECRET!,\n * });\n * ```\n *\n * Cache tags are an App Router feature; the `tags` option is ignored here.\n */\nexport function createPagesRevalidateHandler(\n  options: RevalidateOptions,\n): (req: NextApiRequest, res: NextApiResponse) => Promise<void> {\n  const header = options.secretHeader ?? \"x-plenary-secret\";\n  const query = options.secretQuery ?? \"secret\";\n\n  return async (req, res) => {\n    if (req.method !== \"POST\") {\n      res.status(405).json({ message: \"Method not allowed\" });\n      return;\n    }\n    const fromHeader = req.headers[header];\n    const fromQuery = req.query[query];\n    const provided =\n      (Array.isArray(fromHeader) ? fromHeader[0] : fromHeader) ??\n      (Array.isArray(fromQuery) ? fromQuery[0] : fromQuery);\n    if (!verifyWebhookSecret(provided, options.secret)) {\n      res.status(401).json({ message: \"Invalid webhook secret\" });\n      return;\n    }\n\n    let payload;\n    try {\n      payload = parseWebhookPayload(req.body);\n    } catch (err) {\n      if (err instanceof PlenaryWebhookError) {\n        res.status(err.status).json({ message: err.message });\n        return;\n      }\n      throw err;\n    }\n\n    const plan = planRevalidation(payload, options);\n    if (!plan.relevant) {\n      res.json({ revalidated: false, ignored: payload.event });\n      return;\n    }\n    if (plan.test) {\n      res.json({ test: true, paths: plan.paths });\n      return;\n    }\n    await Promise.all(plan.paths.map((p) => res.revalidate(p)));\n    res.json({ revalidated: true, paths: plan.paths });\n  };\n}\n","/**\n * The revalidation decision, shared by the App Router and Pages Router\n * handlers: which paths (and tags) one webhook payload maps to. Pure — the\n * handlers own the framework calls.\n */\n\nimport {\n  isEntryWebhookPayload,\n  WEBHOOK_TEST_EVENT,\n  type EntryWebhookEvent,\n  type EntryWebhookPayload,\n  type ParseWebhookOptions,\n  type WebhookPayload,\n} from \"@plenary/client\";\nimport { entryTag, modelTag } from \"./tags.js\";\n\n/** Paths for one model: a fixed path, a list, or a function of the payload.\n * A function may return `null`/`undefined` to revalidate nothing. */\nexport type RevalidatePaths =\n  | string\n  | string[]\n  | ((payload: EntryWebhookPayload) => string | string[] | null | undefined);\n\nexport interface RevalidateOptions extends ParseWebhookOptions {\n  /**\n   * Extra or overriding paths per model key. A mapped model replaces the\n   * default URL entirely — include `entryUrl(payload)` (exported) in the\n   * returned list to keep it.\n   */\n  paths?: Record<string, RevalidatePaths>;\n  /** Builds the default URL for unmapped models. Defaults to joining the\n   * entry's folder `path` and `slug`; return `null` to skip. */\n  entryUrl?: (payload: EntryWebhookPayload) => string | null | undefined;\n  /** Entry events that trigger revalidation. Default: all five — revalidation\n   * is idempotent and cheap, so over-firing beats a stale page. */\n  events?: EntryWebhookEvent[];\n  /** Also revalidate the `plenary:model:*` / `plenary:entry:*` cache tags used\n   * by `createTaggedFetch`. App Router only. */\n  tags?: boolean;\n}\n\n/** Default URL for an entry: folder path + slug (`/blog` + `spring-sale` →\n * `/blog/spring-sale`). Entries without a slug (singletons) get no default. */\nexport function entryUrl(payload: EntryWebhookPayload): string | null {\n  const { slug, path } = payload.entry;\n  if (!slug) return null;\n  const dir = path && path !== \"/\" ? path : \"\";\n  return `${dir}/${slug}`;\n}\n\nexport interface RevalidationPlan {\n  /** Whether this payload is one the handler acts on. */\n  relevant: boolean;\n  /** True for the console's Test button — report, don't revalidate. */\n  test: boolean;\n  paths: string[];\n  tags: string[];\n}\n\n/** Decides what one payload revalidates. */\nexport function planRevalidation(\n  payload: WebhookPayload,\n  options: RevalidateOptions,\n): RevalidationPlan {\n  const none = { relevant: false, test: false, paths: [], tags: [] };\n  if (!isEntryWebhookPayload(payload)) return none;\n\n  const test = payload.event === WEBHOOK_TEST_EVENT;\n  if (!test && options.events && !options.events.includes(payload.event as EntryWebhookEvent)) {\n    return none;\n  }\n\n  const modelKey = payload.model.key;\n  const mapped = modelKey === undefined ? undefined : options.paths?.[modelKey];\n  let paths: string | string[] | null | undefined;\n  if (mapped === undefined) {\n    paths = (options.entryUrl ?? entryUrl)(payload);\n  } else {\n    paths = typeof mapped === \"function\" ? mapped(payload) : mapped;\n  }\n  const pathList = paths == null ? [] : typeof paths === \"string\" ? [paths] : paths;\n\n  const tags: string[] = [];\n  if (options.tags) {\n    if (modelKey) tags.push(modelTag(modelKey));\n    tags.push(entryTag(payload.entry.id));\n    if (payload.entry.slug) tags.push(entryTag(payload.entry.slug));\n  }\n\n  return { relevant: true, test, paths: [...new Set(pathList)], tags };\n}\n","/**\n * Cache-tag conventions shared by the tagged fetch and the revalidation\n * handler. A page that fetches Plenary content through\n * {@link createTaggedFetch} is tagged with the model and entry it read, so the\n * webhook handler can revalidate every page that used a piece of content\n * without a path map.\n */\n\n/** Tag carried by every read of a model's content. */\nexport function modelTag(modelKey: string): string {\n  return `plenary:model:${modelKey}`;\n}\n\n/** Tag for one entry. The content API addresses entries by slug or UUID, and a\n * webhook payload carries both, so both spellings are revalidated. */\nexport function entryTag(slugOrId: string): string {\n  return `plenary:entry:${slugOrId}`;\n}\n\n/** Next.js extends `RequestInit` with `next`; declared locally so this package\n * compiles against the standard DOM lib. */\ninterface NextRequestInit extends RequestInit {\n  next?: { tags?: string[]; revalidate?: number | false };\n}\n\nconst CONTENT_URL = /\\/api\\/v1\\/content\\/([^/?#]+)(?:\\/([^/?#]+))?/;\n\n/**\n * Wraps a fetch implementation so Plenary content reads carry cache tags.\n * Pass it to `createClient`:\n *\n * ```ts\n * const plenary = createClient({ ...config, fetch: createTaggedFetch() });\n * ```\n *\n * GET requests to `/api/v1/content/{model}` are tagged with the model, and\n * `/api/v1/content/{model}/{slugOrId}` with the model and the entry. Anything\n * else passes through untouched.\n */\nexport function createTaggedFetch(baseFetch: typeof fetch = fetch): typeof fetch {\n  return ((input: RequestInfo | URL, init?: RequestInit) => {\n    const method = init?.method ?? \"GET\";\n    const url =\n      typeof input === \"string\" ? input : input instanceof URL ? input.href : input.url;\n    const match = method === \"GET\" ? CONTENT_URL.exec(url) : null;\n    if (!match?.[1]) return baseFetch(input, init);\n\n    const tags = [modelTag(decodeURIComponent(match[1]))];\n    if (match[2]) tags.push(entryTag(decodeURIComponent(match[2])));\n    const next = (init as NextRequestInit | undefined)?.next;\n    const merged: NextRequestInit = {\n      ...init,\n      next: { ...next, tags: [...(next?.tags ?? []), ...tags] },\n    };\n    return baseFetch(input, merged);\n  }) as typeof fetch;\n}\n"],"mappings":"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","names":["import_client"]}

package/dist/pages.d.cts

@@ -0,0 +1,20 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { R as RevalidateOptions } from './resolve-DzNy1GAi.cjs';
+import '@plenary/client';
+
+/**
+ * The Pages Router counterpart of `createRevalidateHandler`, built on
+ * `res.revalidate`.
+ *
+ * ```ts
+ * // pages/api/revalidate.ts
+ * export default createPagesRevalidateHandler({
+ *   secret: process.env.PLENARY_WEBHOOK_SECRET!,
+ * });
+ * ```
+ *
+ * Cache tags are an App Router feature; the `tags` option is ignored here.
+ */
+declare function createPagesRevalidateHandler(options: RevalidateOptions): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+
+export { createPagesRevalidateHandler };

package/dist/pages.d.ts

@@ -0,0 +1,20 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { R as RevalidateOptions } from './resolve-DzNy1GAi.js';
+import '@plenary/client';
+
+/**
+ * The Pages Router counterpart of `createRevalidateHandler`, built on
+ * `res.revalidate`.
+ *
+ * ```ts
+ * // pages/api/revalidate.ts
+ * export default createPagesRevalidateHandler({
+ *   secret: process.env.PLENARY_WEBHOOK_SECRET!,
+ * });
+ * ```
+ *
+ * Cache tags are an App Router feature; the `tags` option is ignored here.
+ */
+declare function createPagesRevalidateHandler(options: RevalidateOptions): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+
+export { createPagesRevalidateHandler };

package/dist/pages.js

@@ -0,0 +1,52 @@
+import {
+  planRevalidation
+} from "./chunk-BMLKEIKX.js";
+
+// src/pages.ts
+import {
+  parseWebhookPayload,
+  verifyWebhookSecret,
+  PlenaryWebhookError
+} from "@plenary/client";
+function createPagesRevalidateHandler(options) {
+  const header = options.secretHeader ?? "x-plenary-secret";
+  const query = options.secretQuery ?? "secret";
+  return async (req, res) => {
+    if (req.method !== "POST") {
+      res.status(405).json({ message: "Method not allowed" });
+      return;
+    }
+    const fromHeader = req.headers[header];
+    const fromQuery = req.query[query];
+    const provided = (Array.isArray(fromHeader) ? fromHeader[0] : fromHeader) ?? (Array.isArray(fromQuery) ? fromQuery[0] : fromQuery);
+    if (!verifyWebhookSecret(provided, options.secret)) {
+      res.status(401).json({ message: "Invalid webhook secret" });
+      return;
+    }
+    let payload;
+    try {
+      payload = parseWebhookPayload(req.body);
+    } catch (err) {
+      if (err instanceof PlenaryWebhookError) {
+        res.status(err.status).json({ message: err.message });
+        return;
+      }
+      throw err;
+    }
+    const plan = planRevalidation(payload, options);
+    if (!plan.relevant) {
+      res.json({ revalidated: false, ignored: payload.event });
+      return;
+    }
+    if (plan.test) {
+      res.json({ test: true, paths: plan.paths });
+      return;
+    }
+    await Promise.all(plan.paths.map((p) => res.revalidate(p)));
+    res.json({ revalidated: true, paths: plan.paths });
+  };
+}
+export {
+  createPagesRevalidateHandler
+};
+//# sourceMappingURL=pages.js.map

package/dist/pages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pages.ts"],"sourcesContent":["import type { NextApiRequest, NextApiResponse } from \"next\";\nimport {\n  parseWebhookPayload,\n  verifyWebhookSecret,\n  PlenaryWebhookError,\n} from \"@plenary/client\";\nimport { planRevalidation, type RevalidateOptions } from \"./resolve.js\";\n\n/**\n * The Pages Router counterpart of `createRevalidateHandler`, built on\n * `res.revalidate`.\n *\n * ```ts\n * // pages/api/revalidate.ts\n * export default createPagesRevalidateHandler({\n *   secret: process.env.PLENARY_WEBHOOK_SECRET!,\n * });\n * ```\n *\n * Cache tags are an App Router feature; the `tags` option is ignored here.\n */\nexport function createPagesRevalidateHandler(\n  options: RevalidateOptions,\n): (req: NextApiRequest, res: NextApiResponse) => Promise<void> {\n  const header = options.secretHeader ?? \"x-plenary-secret\";\n  const query = options.secretQuery ?? \"secret\";\n\n  return async (req, res) => {\n    if (req.method !== \"POST\") {\n      res.status(405).json({ message: \"Method not allowed\" });\n      return;\n    }\n    const fromHeader = req.headers[header];\n    const fromQuery = req.query[query];\n    const provided =\n      (Array.isArray(fromHeader) ? fromHeader[0] : fromHeader) ??\n      (Array.isArray(fromQuery) ? fromQuery[0] : fromQuery);\n    if (!verifyWebhookSecret(provided, options.secret)) {\n      res.status(401).json({ message: \"Invalid webhook secret\" });\n      return;\n    }\n\n    let payload;\n    try {\n      payload = parseWebhookPayload(req.body);\n    } catch (err) {\n      if (err instanceof PlenaryWebhookError) {\n        res.status(err.status).json({ message: err.message });\n        return;\n      }\n      throw err;\n    }\n\n    const plan = planRevalidation(payload, options);\n    if (!plan.relevant) {\n      res.json({ revalidated: false, ignored: payload.event });\n      return;\n    }\n    if (plan.test) {\n      res.json({ test: true, paths: plan.paths });\n      return;\n    }\n    await Promise.all(plan.paths.map((p) => res.revalidate(p)));\n    res.json({ revalidated: true, paths: plan.paths });\n  };\n}\n"],"mappings":";;;;;AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAgBA,SAAS,6BACd,SAC8D;AAC9D,QAAM,SAAS,QAAQ,gBAAgB;AACvC,QAAM,QAAQ,QAAQ,eAAe;AAErC,SAAO,OAAO,KAAK,QAAQ;AACzB,QAAI,IAAI,WAAW,QAAQ;AACzB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAE,SAAS,qBAAqB,CAAC;AACtD;AAAA,IACF;AACA,UAAM,aAAa,IAAI,QAAQ,MAAM;AACrC,UAAM,YAAY,IAAI,MAAM,KAAK;AACjC,UAAM,YACH,MAAM,QAAQ,UAAU,IAAI,WAAW,CAAC,IAAI,gBAC5C,MAAM,QAAQ,SAAS,IAAI,UAAU,CAAC,IAAI;AAC7C,QAAI,CAAC,oBAAoB,UAAU,QAAQ,MAAM,GAAG;AAClD,UAAI,OAAO,GAAG,EAAE,KAAK,EAAE,SAAS,yBAAyB,CAAC;AAC1D;AAAA,IACF;AAEA,QAAI;AACJ,QAAI;AACF,gBAAU,oBAAoB,IAAI,IAAI;AAAA,IACxC,SAAS,KAAK;AACZ,UAAI,eAAe,qBAAqB;AACtC,YAAI,OAAO,IAAI,MAAM,EAAE,KAAK,EAAE,SAAS,IAAI,QAAQ,CAAC;AACpD;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAEA,UAAM,OAAO,iBAAiB,SAAS,OAAO;AAC9C,QAAI,CAAC,KAAK,UAAU;AAClB,UAAI,KAAK,EAAE,aAAa,OAAO,SAAS,QAAQ,MAAM,CAAC;AACvD;AAAA,IACF;AACA,QAAI,KAAK,MAAM;AACb,UAAI,KAAK,EAAE,MAAM,MAAM,OAAO,KAAK,MAAM,CAAC;AAC1C;AAAA,IACF;AACA,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC;AAC1D,QAAI,KAAK,EAAE,aAAa,MAAM,OAAO,KAAK,MAAM,CAAC;AAAA,EACnD;AACF;","names":[]}

package/dist/resolve-DzNy1GAi.d.cts

@@ -0,0 +1,43 @@
+import { ParseWebhookOptions, EntryWebhookPayload, EntryWebhookEvent, WebhookPayload } from '@plenary/client';
+
+/**
+ * The revalidation decision, shared by the App Router and Pages Router
+ * handlers: which paths (and tags) one webhook payload maps to. Pure — the
+ * handlers own the framework calls.
+ */
+
+/** Paths for one model: a fixed path, a list, or a function of the payload.
+ * A function may return `null`/`undefined` to revalidate nothing. */
+type RevalidatePaths = string | string[] | ((payload: EntryWebhookPayload) => string | string[] | null | undefined);
+interface RevalidateOptions extends ParseWebhookOptions {
+    /**
+     * Extra or overriding paths per model key. A mapped model replaces the
+     * default URL entirely — include `entryUrl(payload)` (exported) in the
+     * returned list to keep it.
+     */
+    paths?: Record<string, RevalidatePaths>;
+    /** Builds the default URL for unmapped models. Defaults to joining the
+     * entry's folder `path` and `slug`; return `null` to skip. */
+    entryUrl?: (payload: EntryWebhookPayload) => string | null | undefined;
+    /** Entry events that trigger revalidation. Default: all five — revalidation
+     * is idempotent and cheap, so over-firing beats a stale page. */
+    events?: EntryWebhookEvent[];
+    /** Also revalidate the `plenary:model:*` / `plenary:entry:*` cache tags used
+     * by `createTaggedFetch`. App Router only. */
+    tags?: boolean;
+}
+/** Default URL for an entry: folder path + slug (`/blog` + `spring-sale` →
+ * `/blog/spring-sale`). Entries without a slug (singletons) get no default. */
+declare function entryUrl(payload: EntryWebhookPayload): string | null;
+interface RevalidationPlan {
+    /** Whether this payload is one the handler acts on. */
+    relevant: boolean;
+    /** True for the console's Test button — report, don't revalidate. */
+    test: boolean;
+    paths: string[];
+    tags: string[];
+}
+/** Decides what one payload revalidates. */
+declare function planRevalidation(payload: WebhookPayload, options: RevalidateOptions): RevalidationPlan;
+
+export { type RevalidateOptions as R, type RevalidatePaths as a, type RevalidationPlan as b, entryUrl as e, planRevalidation as p };

package/dist/resolve-DzNy1GAi.d.ts

@@ -0,0 +1,43 @@
+import { ParseWebhookOptions, EntryWebhookPayload, EntryWebhookEvent, WebhookPayload } from '@plenary/client';
+
+/**
+ * The revalidation decision, shared by the App Router and Pages Router
+ * handlers: which paths (and tags) one webhook payload maps to. Pure — the
+ * handlers own the framework calls.
+ */
+
+/** Paths for one model: a fixed path, a list, or a function of the payload.
+ * A function may return `null`/`undefined` to revalidate nothing. */
+type RevalidatePaths = string | string[] | ((payload: EntryWebhookPayload) => string | string[] | null | undefined);
+interface RevalidateOptions extends ParseWebhookOptions {
+    /**
+     * Extra or overriding paths per model key. A mapped model replaces the
+     * default URL entirely — include `entryUrl(payload)` (exported) in the
+     * returned list to keep it.
+     */
+    paths?: Record<string, RevalidatePaths>;
+    /** Builds the default URL for unmapped models. Defaults to joining the
+     * entry's folder `path` and `slug`; return `null` to skip. */
+    entryUrl?: (payload: EntryWebhookPayload) => string | null | undefined;
+    /** Entry events that trigger revalidation. Default: all five — revalidation
+     * is idempotent and cheap, so over-firing beats a stale page. */
+    events?: EntryWebhookEvent[];
+    /** Also revalidate the `plenary:model:*` / `plenary:entry:*` cache tags used
+     * by `createTaggedFetch`. App Router only. */
+    tags?: boolean;
+}
+/** Default URL for an entry: folder path + slug (`/blog` + `spring-sale` →
+ * `/blog/spring-sale`). Entries without a slug (singletons) get no default. */
+declare function entryUrl(payload: EntryWebhookPayload): string | null;
+interface RevalidationPlan {
+    /** Whether this payload is one the handler acts on. */
+    relevant: boolean;
+    /** True for the console's Test button — report, don't revalidate. */
+    test: boolean;
+    paths: string[];
+    tags: string[];
+}
+/** Decides what one payload revalidates. */
+declare function planRevalidation(payload: WebhookPayload, options: RevalidateOptions): RevalidationPlan;
+
+export { type RevalidateOptions as R, type RevalidatePaths as a, type RevalidationPlan as b, entryUrl as e, planRevalidation as p };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@plenary/next",
+  "version": "0.1.0",
+  "description": "Plenary Next.js integration: webhook revalidation handlers and cache-tagged fetch.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./pages": {
+      "types": "./dist/pages.d.ts",
+      "import": "./dist/pages.js",
+      "require": "./dist/pages.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@plenary/client": "0.1.0"
+  },
+  "peerDependencies": {
+    "next": "^14 || ^15 || ^16"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.2",
+    "next": "^15.5.12",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}