@plenary/nuxt 0.0.0-stage → 1.2.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

@@ -1,3 +1,106 @@
-# Temporary Holding Version
+# @plenary/nuxt
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Nuxt glue for Plenary: turn entry webhooks into Nitro cache purges, so pages
+cached with `swr`/`cache` route rules or `defineCachedEventHandler` are
+regenerated the moment content changes.
+
+## Setup
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ["@plenary/nuxt"],
+  runtimeConfig: {
+    plenaryWebhookSecret: "", // NUXT_PLENARY_WEBHOOK_SECRET
+  },
+  routeRules: {
+    "/news/**": { swr: 3600 },
+  },
+});
+```
+
+```ts
+// server/api/revalidate.post.ts
+import { createRevalidateHandler } from "@plenary/nuxt/server";
+
+export default createRevalidateHandler({
+  secret: useRuntimeConfig().plenaryWebhookSecret,
+});
+```
+
+The module has no options. It registers the package's server runtime with
+Nitro's bundler so the handler can reach Nitro's cache storage. Without it the
+route answers 500 and the server log says `Package import specifier
+"#nitro-internal-virtual/storage" is not defined`: Nitro's storage only exists
+inside the Nitro bundle.
+
+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 purges the cached responses of the entry's own URL, built from its folder
+path and slug (`/news` + `hello-world` → `/news/hello-world`), and the next
+request renders it fresh.
+
+When a model's URLs don't mirror folder + slug, or other pages show its
+content, map it:
+
+```ts
+export default createRevalidateHandler({
+  secret: useRuntimeConfig().plenaryWebhookSecret,
+  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 `entryUrl` from
+`@plenary/client` 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
+purged.
+
+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.
+A successful delivery reports `purged`, the number of cache entries removed:
+a persistent `0` for a page you know is cached usually means the cache lives
+somewhere the handler can't see (below).
+
+## What gets purged
+
+Nitro has no cache tags. A cached response is stored under a key derived from
+its request URL (`cache:nitro:routes:_:newshelloworld.<hash>.json` for
+`/news/hello-world`), so the handler lists the `nitro:routes` and
+`nitro:handlers` groups of `useStorage("cache")` and removes every entry filed
+under one of the planned paths — all of a page's variants, including query
+strings and `varies` headers. Nitro keeps only the first 16 word characters of
+the path in the key, so a purge of a long path also removes pages sharing that
+prefix (`/blog/2026/11/03/some-title` and `/blog/2026/11/03/some-other`). That
+is harmless: the next request regenerates them.
+
+Things the handler cannot reach:
+
+- **Per-instance memory.** Nitro's default `cache` storage in production is
+  in-memory, so on a platform that runs several instances the purge only hits
+  the one that received the webhook. Mount a shared driver
+  (`nitro.storage.cache` → Redis, Cloudflare KV, Vercel KV, …) so every
+  instance sees it.
+- **Platform ISR.** The `isr` route rule on Vercel and Netlify caches at the
+  platform's CDN, outside Nitro's storage. Use `swr` with a shared cache
+  driver instead, or purge through the platform's API.
+- **`defineCachedFunction`.** Its keys are whatever your `getKey` returns, so
+  the handler leaves the `nitro:functions` group alone. Give such functions a
+  `maxAge` you can live with, or purge them yourself from a custom route built
+  on `purgeCachedPaths` (exported here) and `planRevalidation` (from
+  `@plenary/client`).
+- **Custom `getKey`** on a cached handler, for the same reason.
+
+## 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, verification, and the path planning (`entryUrl`, `planRevalidation`)
+live in `@plenary/client` for use outside Nuxt; HMAC verification will land
+there when signing ships.

package/dist/module.d.ts

@@ -0,0 +1,19 @@
+import { NuxtModule } from '@nuxt/schema';
+
+/**
+ * The `@plenary/nuxt` module. It has no options: its one job is to hand the
+ * package's server runtime to Nitro's bundler, so a route built with
+ * `createRevalidateHandler` (from `@plenary/nuxt/server`) can reach Nitro's
+ * cache storage. `nitropack/runtime` only exists inside the Nitro bundle —
+ * loaded from node_modules at runtime it fails with `Package import specifier
+ * "#nitro-internal-virtual/storage" is not defined` — so the runtime
+ * directory is transpiled (inlined) rather than left external.
+ *
+ * ```ts
+ * // nuxt.config.ts
+ * export default defineNuxtConfig({ modules: ["@plenary/nuxt"] });
+ * ```
+ */
+declare const module$1: NuxtModule;
+
+export { module$1 as default };

package/dist/module.js

@@ -0,0 +1,17 @@
+import { createResolver, defineNuxtModule } from "@nuxt/kit";
+const module = defineNuxtModule({
+  meta: {
+    name: "@plenary/nuxt",
+    configKey: "plenary",
+    compatibility: { nuxt: ">=4.0.0" }
+  },
+  setup(_options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    nuxt.options.build.transpile.push(resolve("./runtime"));
+  }
+});
+var module_default = module;
+export {
+  module_default as default
+};
+//# sourceMappingURL=module.js.map

package/dist/module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/module.ts"],"sourcesContent":["import { createResolver, defineNuxtModule } from \"@nuxt/kit\";\nimport type { NuxtModule } from \"@nuxt/schema\";\n\n/**\n * The `@plenary/nuxt` module. It has no options: its one job is to hand the\n * package's server runtime to Nitro's bundler, so a route built with\n * `createRevalidateHandler` (from `@plenary/nuxt/server`) can reach Nitro's\n * cache storage. `nitropack/runtime` only exists inside the Nitro bundle —\n * loaded from node_modules at runtime it fails with `Package import specifier\n * \"#nitro-internal-virtual/storage\" is not defined` — so the runtime\n * directory is transpiled (inlined) rather than left external.\n *\n * ```ts\n * // nuxt.config.ts\n * export default defineNuxtConfig({ modules: [\"@plenary/nuxt\"] });\n * ```\n */\nconst module: NuxtModule = defineNuxtModule({\n  meta: {\n    name: \"@plenary/nuxt\",\n    configKey: \"plenary\",\n    compatibility: { nuxt: \">=4.0.0\" },\n  },\n  setup(_options, nuxt) {\n    const { resolve } = createResolver(import.meta.url);\n    nuxt.options.build.transpile.push(resolve(\"./runtime\"));\n  },\n});\n\nexport default module;\n"],"mappings":"AAAA,SAAS,gBAAgB,wBAAwB;AAiBjD,MAAM,SAAqB,iBAAiB;AAAA,EAC1C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,WAAW;AAAA,IACX,eAAe,EAAE,MAAM,UAAU;AAAA,EACnC;AAAA,EACA,MAAM,UAAU,MAAM;AACpB,UAAM,EAAE,QAAQ,IAAI,eAAe,YAAY,GAAG;AAClD,SAAK,QAAQ,MAAM,UAAU,KAAK,QAAQ,WAAW,CAAC;AAAA,EACxD;AACF,CAAC;AAED,IAAO,iBAAQ;","names":[]}

package/dist/runtime/server/cache.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Purging Nitro's response cache by path. Nitro has no cache tags: a cached
+ * response lives under a storage key derived from the request URL, so
+ * revalidating a path means finding and removing the keys that belong to it.
+ *
+ * `defineCachedEventHandler` (and the `cache`/`swr`/`isr` route rules, which
+ * wrap handlers in it) store entries as
+ *
+ *     cache:nitro:routes:<name>:<pathname>.<hash>[:<header>.<hash>…].json
+ *     cache:nitro:handlers:<name>:<pathname>.<hash>[:<header>.<hash>…].json
+ *
+ * where `<pathname>` is the URL path with every non-word character stripped
+ * and cut to 16 characters (`/news/hello-world` → `newshelloworld`, `/` →
+ * `index`) and `<hash>` digests the full URL including its query string. The
+ * hash is not recomputed here; entries are matched on the pathname part, so a
+ * purge of `/news/hello-world` also removes `/news/hello-world?utm=x` — every
+ * cached variant of the page — and, for paths whose stripped form exceeds 16
+ * characters, any other page sharing that prefix. Over-purging is harmless:
+ * the next request regenerates the page.
+ */
+/** The slice of Nitro's `useStorage("cache")` the purge needs. Structural so
+ * the published types don't depend on `unstorage`. */
+interface CacheStorage {
+    getKeys(base?: string): Promise<string[]>;
+    removeItem(key: string): Promise<void>;
+}
+/** The `<pathname>` part Nitro files a path's cached responses under. */
+declare function cacheKeyPathname(path: string): string;
+/** Removes every cached response filed under one of `paths`. Returns the
+ * number of entries removed. */
+declare function purgeCachedPaths(storage: CacheStorage, paths: string[]): Promise<number>;
+
+export { type CacheStorage, cacheKeyPathname, purgeCachedPaths };

package/dist/runtime/server/cache.js

@@ -0,0 +1,29 @@
+const PATH_KEYED_GROUPS = ["nitro:routes", "nitro:handlers"];
+function cacheKeyPathname(path) {
+  const pathname = path.split(/[?#]/, 1)[0] ?? "";
+  let decoded;
+  try {
+    decoded = decodeURI(pathname);
+  } catch {
+    return "-";
+  }
+  return decoded.replace(/\W/g, "").slice(0, 16) || "index";
+}
+async function purgeCachedPaths(storage, paths) {
+  if (paths.length === 0) return 0;
+  const wanted = new Set(paths.map(cacheKeyPathname));
+  const matches = [];
+  for (const group of PATH_KEYED_GROUPS) {
+    for (const key of await storage.getKeys(group)) {
+      const pathname = key.slice(group.length + 1).split(":")[1]?.split(".")[0];
+      if (pathname !== void 0 && wanted.has(pathname)) matches.push(key);
+    }
+  }
+  await Promise.all(matches.map((key) => storage.removeItem(key)));
+  return matches.length;
+}
+export {
+  cacheKeyPathname,
+  purgeCachedPaths
+};
+//# sourceMappingURL=cache.js.map

package/dist/runtime/server/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/runtime/server/cache.ts"],"sourcesContent":["/**\n * Purging Nitro's response cache by path. Nitro has no cache tags: a cached\n * response lives under a storage key derived from the request URL, so\n * revalidating a path means finding and removing the keys that belong to it.\n *\n * `defineCachedEventHandler` (and the `cache`/`swr`/`isr` route rules, which\n * wrap handlers in it) store entries as\n *\n *     cache:nitro:routes:<name>:<pathname>.<hash>[:<header>.<hash>…].json\n *     cache:nitro:handlers:<name>:<pathname>.<hash>[:<header>.<hash>…].json\n *\n * where `<pathname>` is the URL path with every non-word character stripped\n * and cut to 16 characters (`/news/hello-world` → `newshelloworld`, `/` →\n * `index`) and `<hash>` digests the full URL including its query string. The\n * hash is not recomputed here; entries are matched on the pathname part, so a\n * purge of `/news/hello-world` also removes `/news/hello-world?utm=x` — every\n * cached variant of the page — and, for paths whose stripped form exceeds 16\n * characters, any other page sharing that prefix. Over-purging is harmless:\n * the next request regenerates the page.\n */\n\n/** The slice of Nitro's `useStorage(\"cache\")` the purge needs. Structural so\n * the published types don't depend on `unstorage`. */\nexport interface CacheStorage {\n  getKeys(base?: string): Promise<string[]>;\n  removeItem(key: string): Promise<void>;\n}\n\n/** Cache groups whose keys follow the request-path convention: route rules\n * and `defineCachedEventHandler`. `nitro:functions` keys are caller-defined\n * and left alone. */\nconst PATH_KEYED_GROUPS = [\"nitro:routes\", \"nitro:handlers\"];\n\n/** The `<pathname>` part Nitro files a path's cached responses under. */\nexport function cacheKeyPathname(path: string): string {\n  const pathname = path.split(/[?#]/, 1)[0] ?? \"\";\n  let decoded: string;\n  try {\n    decoded = decodeURI(pathname);\n  } catch {\n    return \"-\";\n  }\n  return decoded.replace(/\\W/g, \"\").slice(0, 16) || \"index\";\n}\n\n/** Removes every cached response filed under one of `paths`. Returns the\n * number of entries removed. */\nexport async function purgeCachedPaths(storage: CacheStorage, paths: string[]): Promise<number> {\n  if (paths.length === 0) return 0;\n  const wanted = new Set(paths.map(cacheKeyPathname));\n  const matches: string[] = [];\n  for (const group of PATH_KEYED_GROUPS) {\n    for (const key of await storage.getKeys(group)) {\n      // key = <group>:<name>:<pathname>.<hash>[:…].json\n      const pathname = key.slice(group.length + 1).split(\":\")[1]?.split(\".\")[0];\n      if (pathname !== undefined && wanted.has(pathname)) matches.push(key);\n    }\n  }\n  await Promise.all(matches.map((key) => storage.removeItem(key)));\n  return matches.length;\n}\n"],"mappings":"AA+BA,MAAM,oBAAoB,CAAC,gBAAgB,gBAAgB;AAGpD,SAAS,iBAAiB,MAAsB;AACrD,QAAM,WAAW,KAAK,MAAM,QAAQ,CAAC,EAAE,CAAC,KAAK;AAC7C,MAAI;AACJ,MAAI;AACF,cAAU,UAAU,QAAQ;AAAA,EAC9B,QAAQ;AACN,WAAO;AAAA,EACT;AACA,SAAO,QAAQ,QAAQ,OAAO,EAAE,EAAE,MAAM,GAAG,EAAE,KAAK;AACpD;AAIA,eAAsB,iBAAiB,SAAuB,OAAkC;AAC9F,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,QAAM,SAAS,IAAI,IAAI,MAAM,IAAI,gBAAgB,CAAC;AAClD,QAAM,UAAoB,CAAC;AAC3B,aAAW,SAAS,mBAAmB;AACrC,eAAW,OAAO,MAAM,QAAQ,QAAQ,KAAK,GAAG;AAE9C,YAAM,WAAW,IAAI,MAAM,MAAM,SAAS,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,EAAE,CAAC;AACxE,UAAI,aAAa,UAAa,OAAO,IAAI,QAAQ,EAAG,SAAQ,KAAK,GAAG;AAAA,IACtE;AAAA,EACF;AACA,QAAM,QAAQ,IAAI,QAAQ,IAAI,CAAC,QAAQ,QAAQ,WAAW,GAAG,CAAC,CAAC;AAC/D,SAAO,QAAQ;AACjB;","names":[]}

package/dist/runtime/server/index.d.ts

@@ -0,0 +1,4 @@
+export { createRevalidateHandler } from './revalidate.js';
+export { CacheStorage, cacheKeyPathname, purgeCachedPaths } from './cache.js';
+export { RevalidateOptions, RevalidatePaths, RevalidationPlan } from '@plenary/client';
+import 'h3';

package/dist/runtime/server/index.js

@@ -0,0 +1,8 @@
+import { createRevalidateHandler } from "./revalidate.js";
+import { purgeCachedPaths, cacheKeyPathname } from "./cache.js";
+export {
+  cacheKeyPathname,
+  createRevalidateHandler,
+  purgeCachedPaths
+};
+//# sourceMappingURL=index.js.map

package/dist/runtime/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/runtime/server/index.ts"],"sourcesContent":["/**\n * @plenary/nuxt/server — the server side of the Nuxt integration: a webhook\n * handler that purges Nitro's response cache for the paths an entry event\n * touches. Import it from `server/` routes; the `@plenary/nuxt` module must\n * be enabled for it to reach Nitro's storage.\n *\n * The path planner (`entryUrl`, `planRevalidation`) is `@plenary/client`'s and\n * is imported from there: re-exporting it here would make Nitro's bundler warn\n * about unused external imports on every build of a route that doesn't use it.\n */\n\nexport { createRevalidateHandler } from \"./revalidate.js\";\nexport { purgeCachedPaths, cacheKeyPathname, type CacheStorage } from \"./cache.js\";\nexport type { RevalidateOptions, RevalidatePaths, RevalidationPlan } from \"@plenary/client\";\n"],"mappings":"AAWA,SAAS,+BAA+B;AACxC,SAAS,kBAAkB,wBAA2C;","names":[]}

package/dist/runtime/server/revalidate.d.ts

@@ -0,0 +1,57 @@
+import * as _plenary_client from '@plenary/client';
+import { RevalidateOptions } from '@plenary/client';
+import * as h3 from 'h3';
+
+/**
+ * Builds a Nitro event handler that turns Plenary entry webhooks into cache
+ * purges: every cached response of the entry's paths — `swr`/`cache` route
+ * rules and `defineCachedEventHandler` routes — is removed, so the next
+ * request renders fresh content.
+ *
+ * ```ts
+ * // server/api/revalidate.post.ts
+ * import { createRevalidateHandler } from "@plenary/nuxt/server";
+ *
+ * export default createRevalidateHandler({
+ *   secret: useRuntimeConfig().plenaryWebhookSecret,
+ * });
+ * ```
+ *
+ * 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 purged, without touching the cache.
+ */
+declare function createRevalidateHandler(options: RevalidateOptions): h3.EventHandler<h3.EventHandlerRequest, Promise<{
+    message: string;
+    revalidated?: undefined;
+    ignored?: undefined;
+    test?: undefined;
+    paths?: undefined;
+    purged?: undefined;
+} | {
+    revalidated: boolean;
+    ignored: _plenary_client.EntryWebhookEvent | "webhook.test" | "form.submitted";
+    message?: undefined;
+    test?: undefined;
+    paths?: undefined;
+    purged?: undefined;
+} | {
+    test: boolean;
+    paths: string[];
+    message?: undefined;
+    revalidated?: undefined;
+    ignored?: undefined;
+    purged?: undefined;
+} | {
+    revalidated: boolean;
+    paths: string[];
+    purged: number;
+    message?: undefined;
+    ignored?: undefined;
+    test?: undefined;
+}>>;
+
+export { createRevalidateHandler };

package/dist/runtime/server/revalidate.js

@@ -0,0 +1,35 @@
+import { defineEventHandler, setResponseStatus, toWebRequest } from "h3";
+import { useStorage } from "nitropack/runtime";
+import {
+  parseWebhookRequest,
+  planRevalidation,
+  PlenaryWebhookError
+} from "@plenary/client";
+import { purgeCachedPaths } from "./cache.js";
+function createRevalidateHandler(options) {
+  return defineEventHandler(async (event) => {
+    let payload;
+    try {
+      payload = await parseWebhookRequest(toWebRequest(event), options);
+    } catch (err) {
+      if (err instanceof PlenaryWebhookError) {
+        setResponseStatus(event, err.status);
+        return { message: err.message };
+      }
+      throw err;
+    }
+    const plan = planRevalidation(payload, options);
+    if (!plan.relevant) {
+      return { revalidated: false, ignored: payload.event };
+    }
+    if (plan.test) {
+      return { test: true, paths: plan.paths };
+    }
+    const purged = await purgeCachedPaths(useStorage("cache"), plan.paths);
+    return { revalidated: true, paths: plan.paths, purged };
+  });
+}
+export {
+  createRevalidateHandler
+};
+//# sourceMappingURL=revalidate.js.map

package/dist/runtime/server/revalidate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/runtime/server/revalidate.ts"],"sourcesContent":["import { defineEventHandler, setResponseStatus, toWebRequest } from \"h3\";\nimport { useStorage } from \"nitropack/runtime\";\nimport {\n  parseWebhookRequest,\n  planRevalidation,\n  PlenaryWebhookError,\n  type RevalidateOptions,\n} from \"@plenary/client\";\nimport { purgeCachedPaths } from \"./cache.js\";\n\n/**\n * Builds a Nitro event handler that turns Plenary entry webhooks into cache\n * purges: every cached response of the entry's paths — `swr`/`cache` route\n * rules and `defineCachedEventHandler` routes — is removed, so the next\n * request renders fresh content.\n *\n * ```ts\n * // server/api/revalidate.post.ts\n * import { createRevalidateHandler } from \"@plenary/nuxt/server\";\n *\n * export default createRevalidateHandler({\n *   secret: useRuntimeConfig().plenaryWebhookSecret,\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 purged, without touching the cache.\n */\nexport function createRevalidateHandler(options: RevalidateOptions) {\n  return defineEventHandler(async (event) => {\n    let payload;\n    try {\n      payload = await parseWebhookRequest(toWebRequest(event), options);\n    } catch (err) {\n      if (err instanceof PlenaryWebhookError) {\n        setResponseStatus(event, err.status);\n        return { message: err.message };\n      }\n      throw err;\n    }\n\n    const plan = planRevalidation(payload, options);\n    if (!plan.relevant) {\n      return { revalidated: false, ignored: payload.event };\n    }\n    if (plan.test) {\n      return { test: true, paths: plan.paths };\n    }\n    const purged = await purgeCachedPaths(useStorage(\"cache\"), plan.paths);\n    return { revalidated: true, paths: plan.paths, purged };\n  });\n}\n"],"mappings":"AAAA,SAAS,oBAAoB,mBAAmB,oBAAoB;AACpE,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,wBAAwB;AAwB1B,SAAS,wBAAwB,SAA4B;AAClE,SAAO,mBAAmB,OAAO,UAAU;AACzC,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,oBAAoB,aAAa,KAAK,GAAG,OAAO;AAAA,IAClE,SAAS,KAAK;AACZ,UAAI,eAAe,qBAAqB;AACtC,0BAAkB,OAAO,IAAI,MAAM;AACnC,eAAO,EAAE,SAAS,IAAI,QAAQ;AAAA,MAChC;AACA,YAAM;AAAA,IACR;AAEA,UAAM,OAAO,iBAAiB,SAAS,OAAO;AAC9C,QAAI,CAAC,KAAK,UAAU;AAClB,aAAO,EAAE,aAAa,OAAO,SAAS,QAAQ,MAAM;AAAA,IACtD;AACA,QAAI,KAAK,MAAM;AACb,aAAO,EAAE,MAAM,MAAM,OAAO,KAAK,MAAM;AAAA,IACzC;AACA,UAAM,SAAS,MAAM,iBAAiB,WAAW,OAAO,GAAG,KAAK,KAAK;AACrE,WAAO,EAAE,aAAa,MAAM,OAAO,KAAK,OAAO,OAAO;AAAA,EACxD,CAAC;AACH;","names":[]}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@plenary/nuxt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.2.0",
+  "description": "Plenary Nuxt integration: a module and server handler that turn entry webhooks into Nitro cache purges.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/module.js",
+  "module": "./dist/module.js",
+  "types": "./dist/module.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.js"
+    },
+    "./server": {
+      "types": "./dist/runtime/server/index.d.ts",
+      "import": "./dist/runtime/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/kit": "^4.6.0",
+    "h3": "^1.15.0",
+    "@plenary/client": "1.2.0"
+  },
+  "devDependencies": {
+    "@nuxt/schema": "^4.6.0",
+    "@types/node": "^26.1.2",
+    "nitropack": "^2.13.6",
+    "unstorage": "^1.17.5"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }