kizlo 0.2.1 → 0.3.0

package/dist/integrations/nextjs/kizlo.server.js

@@ -1,12 +1,14 @@
 import { Kizlo, resolveKizloConfig } from "../../kizlo.js";
+import { nextRevalidation } from "./revalidate.js";
 
 //#region src/integrations/nextjs/kizlo.server.ts
-/**
-* Creates a Kizlo server for Next.js — same as the base `createKizlo`, but reads
-* the public base URL from `NEXT_PUBLIC_KIZLO_BACKEND_URL`.
-*/
 function createKizlo(options) {
-	return new Kizlo(resolveKizloConfig(options, { baseUrlEnvKey: "NEXT_PUBLIC_KIZLO_BACKEND_URL" }));
+	const revalidate = options?.revalidate;
+	const extensions = [...revalidate === false ? [] : [nextRevalidation(typeof revalidate === "object" ? revalidate : void 0)], ...options?.extensions ?? []];
+	return new Kizlo(resolveKizloConfig({
+		...options,
+		extensions
+	}, { baseUrlEnvKey: "NEXT_PUBLIC_KIZLO_BACKEND_URL" }));
 }
 
 //#endregion

package/dist/integrations/nextjs/revalidate.d.ts

@@ -0,0 +1,28 @@
+import { KizloEvent } from "../../webhook/schema.js";
+import "../../index.js";
+import { Pathname } from "@kizlo/shared";
+
+//#region src/integrations/nextjs/revalidate.d.ts
+type RevalidatePathFn = (path: string, type?: "layout" | "page") => void;
+type RevalidateTagFn = (tag: string, profile: string | {
+  expire?: number;
+}) => void;
+type RevalidateTarget = Pathname | {
+  path: Pathname;
+  type?: "layout" | "page";
+};
+interface NextRevalidateOptions {
+  revalidateTag?: RevalidateTagFn;
+  revalidatePath?: RevalidatePathFn;
+  /** Return extra paths to revalidate for a given event, on top of the event's own URL. */
+  paths?: (event: KizloEvent) => Pathname[] | Promise<Pathname[]>;
+  /**
+   * How to revalidate the sitemap. Defaults to the route `createSitemapRoute` serves
+   * (`/sitemaps/[sitemap]`, revalidated as a `layout` so the whole on-demand subtree
+   * refreshes at once). Override this only if you serve sitemaps from your own route(s)
+   * instead of `createSitemapRoute`; pass `false` to skip sitemap revalidation.
+   */
+  sitemap?: false | RevalidateTarget | RevalidateTarget[];
+}
+//#endregion
+export { NextRevalidateOptions };

package/dist/integrations/nextjs/revalidate.js

@@ -0,0 +1,49 @@
+import { POST_EVENT_TYPES, TERM_EVENT_TYPES } from "../../webhook/schema.js";
+import { createEventHandler } from "../../webhook/index.js";
+import { createExtension } from "../../shared/extension.js";
+import { ROBOTS_CACHE_TAG } from "./robots.js";
+import { SITEMAP_ROUTE } from "./sitemap.js";
+
+//#region src/integrations/nextjs/revalidate.ts
+const DEFAULT_SITEMAP_TARGET = {
+	path: SITEMAP_ROUTE,
+	type: "layout"
+};
+const CONTENT_EVENT_TYPES = new Set([...POST_EVENT_TYPES, ...TERM_EVENT_TYPES]);
+function nextRevalidation(options) {
+	return createExtension({
+		id: "nextjs-revalidation",
+		init: () => ({ events: [createEventHandler(async (event) => {
+			if (!event) return;
+			const revalidatePath = options?.revalidatePath ?? (await import("next/cache")).revalidatePath;
+			const revalidateTag = options?.revalidateTag ?? (await import("next/cache")).revalidateTag;
+			const paths = [
+				...await Promise.resolve(options?.paths?.(event) ?? []),
+				...event.data?.url ? [event.data.url] : [],
+				"/post"
+			];
+			for (const path of normalizePaths(paths)) revalidatePath(path);
+			if (event.type === "settings.saved") revalidateTag(ROBOTS_CACHE_TAG, { expire: 0 });
+			if (CONTENT_EVENT_TYPES.has(event.type)) for (const target of resolveSitemapTargets(options?.sitemap)) revalidatePath(normalizePath(target.path), target.type);
+		})] })
+	});
+}
+function resolveSitemapTargets(option) {
+	if (option === false) return [];
+	return (option === void 0 ? [DEFAULT_SITEMAP_TARGET] : Array.isArray(option) ? option : [option]).map((target) => typeof target === "string" ? { path: target } : target);
+}
+function normalizePaths(paths) {
+	return Array.from(new Set((Array.isArray(paths) ? paths : paths ? [paths] : []).map(normalizePath).filter(Boolean)));
+}
+function normalizePath(path) {
+	try {
+		return normalizePath(new URL(path).pathname);
+	} catch {
+		const trimmed = path.trim();
+		if (!trimmed) return "";
+		return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+	}
+}
+
+//#endregion
+export { nextRevalidation };

package/dist/integrations/nextjs/robots.d.ts

@@ -0,0 +1,7 @@
+import { S2SClient } from "../../kizlo.js";
+
+//#region src/integrations/nextjs/robots.d.ts
+
+declare function createRobotsRoute(client: S2SClient<[]>): (request: Request) => Promise<Response>;
+//#endregion
+export { createRobotsRoute };

package/dist/integrations/nextjs/robots.js

@@ -0,0 +1,23 @@
+import { createRobotsRoute } from "../../seo/robots.js";
+
+//#region src/integrations/nextjs/robots.ts
+/**
+* Cache tag for the cached robots.txt body. The Next revalidation extension calls
+* `revalidateTag(ROBOTS_CACHE_TAG)` on every webhook event so the route refreshes
+* on-demand instead of on every request.
+*/
+const ROBOTS_CACHE_TAG = "kizlo:robots";
+function createRobotsRoute$1(client) {
+	const handler = createRobotsRoute(client);
+	let getBody;
+	return async function GET(request) {
+		if (!getBody) {
+			const { unstable_cache } = await import("next/cache");
+			getBody = unstable_cache(async () => (await handler(request)).text(), [ROBOTS_CACHE_TAG], { tags: [ROBOTS_CACHE_TAG] });
+		}
+		return new Response(await getBody(), { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+	};
+}
+
+//#endregion
+export { ROBOTS_CACHE_TAG, createRobotsRoute$1 as createRobotsRoute };

package/dist/integrations/nextjs/seo.d.ts

@@ -0,0 +1,7 @@
+import { SeoHead } from "../../seo/schema.js";
+import { Metadata } from "next";
+
+//#region src/integrations/nextjs/seo.d.ts
+declare function toMetadata(head: SeoHead): Metadata;
+//#endregion
+export { toMetadata };

package/dist/integrations/nextjs/seo.js

@@ -0,0 +1,41 @@
+//#region src/integrations/nextjs/seo.ts
+function toMetadata(head) {
+	const robots = [
+		head.robots.index,
+		head.robots.follow,
+		head.robots.maxSnippet,
+		head.robots.maxImagePreview,
+		head.robots.maxVideoPreview
+	].join(", ");
+	return {
+		title: { absolute: head.title },
+		description: head.og.description || void 0,
+		alternates: { canonical: head.canonical },
+		robots,
+		openGraph: {
+			type: head.og.type,
+			title: head.og.title,
+			description: head.og.description || void 0,
+			url: head.og.url,
+			siteName: head.og.siteName,
+			locale: head.og.locale,
+			images: head.og.image ? [{
+				url: head.og.image.url,
+				width: head.og.image.width,
+				height: head.og.image.height,
+				alt: head.og.image.alt ?? void 0
+			}] : void 0
+		},
+		twitter: {
+			card: head.twitter.card,
+			title: head.twitter.title,
+			description: head.twitter.description || void 0,
+			site: head.twitter.site ?? void 0,
+			creator: head.twitter.creator ?? void 0,
+			images: head.twitter.image ? [head.twitter.image] : void 0
+		}
+	};
+}
+
+//#endregion
+export { toMetadata };

package/dist/integrations/nextjs/sitemap.d.ts

@@ -0,0 +1,33 @@
+import { S2SClient } from "../../kizlo.js";
+import { CreateSitemapRouteOptions } from "../../seo/sitemap.js";
+
+//#region src/integrations/nextjs/sitemap.d.ts
+
+/**
+ * The Next route the sitemap handler is mounted at: a single dynamic segment named
+ * `[sitemap]`. It is fixed (not configurable) so that one `revalidatePath(SITEMAP_ROUTE,
+ * "layout")` refreshes the index and every generated sitemap at once. A `layout`
+ * revalidation (not `page`) is required because the route has no `generateStaticParams`,
+ * so its slugs are generated on-demand and only a subtree invalidation reaches them.
+ * `[sitemap]` is Next's file-routing convention, which is why it lives in this integration
+ * and not in core.
+ */
+declare const SITEMAP_ROUTE: "/sitemaps/[sitemap]";
+/** Next's dynamic-route context. `params` is a promise in the App Router. */
+interface NextRouteContext {
+  params?: {
+    sitemap?: string;
+  } | Promise<{
+    sitemap?: string;
+  }>;
+}
+/**
+ * Next wrapper around the framework-agnostic {@link createCoreSitemapRoute}. It serves the
+ * same sitemap index and collection pages, and additionally asserts the route is mounted at
+ * {@link SITEMAP_ROUTE}: if the dynamic segment is not named `[sitemap]`, `params.sitemap`
+ * is missing and a wrong mount would silently break `revalidatePath(SITEMAP_ROUTE, "layout")`,
+ * so it throws loudly on the first request instead.
+ */
+declare function createSitemapRoute(client: S2SClient<[]>, options?: CreateSitemapRouteOptions): (request: Request, ctx?: NextRouteContext) => Promise<Response>;
+//#endregion
+export { SITEMAP_ROUTE, createSitemapRoute };

package/dist/integrations/nextjs/sitemap.js

@@ -0,0 +1,31 @@
+import { SITEMAP_BASE, createSitemapRoute } from "../../seo/sitemap.js";
+
+//#region src/integrations/nextjs/sitemap.ts
+/**
+* The Next route the sitemap handler is mounted at: a single dynamic segment named
+* `[sitemap]`. It is fixed (not configurable) so that one `revalidatePath(SITEMAP_ROUTE,
+* "layout")` refreshes the index and every generated sitemap at once. A `layout`
+* revalidation (not `page`) is required because the route has no `generateStaticParams`,
+* so its slugs are generated on-demand and only a subtree invalidation reaches them.
+* `[sitemap]` is Next's file-routing convention, which is why it lives in this integration
+* and not in core.
+*/
+const SITEMAP_ROUTE = `${SITEMAP_BASE}/[sitemap]`;
+/**
+* Next wrapper around the framework-agnostic {@link createCoreSitemapRoute}. It serves the
+* same sitemap index and collection pages, and additionally asserts the route is mounted at
+* {@link SITEMAP_ROUTE}: if the dynamic segment is not named `[sitemap]`, `params.sitemap`
+* is missing and a wrong mount would silently break `revalidatePath(SITEMAP_ROUTE, "layout")`,
+* so it throws loudly on the first request instead.
+*/
+function createSitemapRoute$1(client, options) {
+	const handler = createSitemapRoute(client, options);
+	return async function GET(request, ctx) {
+		const params = ctx?.params ? await ctx.params : void 0;
+		if (params && params.sitemap === void 0) throw new Error(`createSitemapRoute must be mounted at "${SITEMAP_ROUTE}". The dynamic segment must be named [sitemap].`);
+		return handler(request);
+	};
+}
+
+//#endregion
+export { SITEMAP_ROUTE, createSitemapRoute$1 as createSitemapRoute };

package/dist/nextjs/server.d.ts

@@ -1,2 +1,4 @@
 import { KizloServerOptions, createKizlo } from "../integrations/nextjs/kizlo.server.js";
-export { KizloServerOptions, createKizlo };
+import { createRobotsRoute } from "../integrations/nextjs/robots.js";
+import { SITEMAP_ROUTE, createSitemapRoute } from "../integrations/nextjs/sitemap.js";
+export { KizloServerOptions, SITEMAP_ROUTE, createKizlo, createRobotsRoute, createSitemapRoute };

package/dist/nextjs/server.js

@@ -1,3 +1,5 @@
+import { createRobotsRoute } from "../integrations/nextjs/robots.js";
+import { SITEMAP_ROUTE, createSitemapRoute } from "../integrations/nextjs/sitemap.js";
 import { createKizlo } from "../integrations/nextjs/kizlo.server.js";
 
-export { createKizlo };
+export { SITEMAP_ROUTE, createKizlo, createRobotsRoute, createSitemapRoute };

package/dist/nextjs.d.ts

@@ -1,2 +1,3 @@
 import { KizloClientOptions, createKizloClient } from "./integrations/nextjs/kizlo.client.js";
-export { KizloClientOptions, createKizloClient };
+import { toMetadata } from "./integrations/nextjs/seo.js";
+export { KizloClientOptions, createKizloClient, toMetadata };

package/dist/nextjs.js

@@ -1,3 +1,4 @@
 import { createKizloClient } from "./integrations/nextjs/kizlo.client.js";
+import { toMetadata } from "./integrations/nextjs/seo.js";
 
-export { createKizloClient };
+export { createKizloClient, toMetadata };

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.2.1";
+var version = "0.3.0";
 
 //#endregion
 export { version };

package/dist/post/index.js

@@ -1,5 +1,5 @@
-import { createProcedure } from "../shared/procedure.js";
 import { compare } from "../shared/crypto.js";
+import { createProcedure } from "../shared/procedure.js";
 import { deserializeListMetadata } from "../shared/serialize.js";
 import { getPostTypeService } from "../post-type/service.js";
 import { parseIdentifier } from "../shared/identifier.js";
@@ -59,7 +59,7 @@ const POST_ROUTER_MAP = {
 		}
 		const data = response.data;
 		if (input.query?.password && data.password) {
-			if (!compare(input.query.password, data.password)) throw errors.POST_PASSWORD_INVALID();
+			if (!await compare(input.query.password, data.password)) throw errors.POST_PASSWORD_INVALID();
 			return deserializePost({
 				...data,
 				password: ""

package/dist/router.d.ts

@@ -21,7 +21,7 @@ declare const ROUTER_MAP: {
       excerpt: string | null;
       commentsEnabled: boolean;
       protected: boolean;
-      format: "image" | "link" | "standard" | "aside" | "chat" | "gallery" | "quote" | "status" | "video" | "audio";
+      format: "standard" | "aside" | "chat" | "gallery" | "link" | "image" | "quote" | "status" | "video" | "audio";
       sticky: boolean;
       author: {
         id: number;
@@ -150,7 +150,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "title" | "author" | "date" | "id" | "parent" | "slug" | "include" | "relevance" | "include_slugs" | undefined;
+        orderby?: "date" | "id" | "slug" | "title" | "author" | "include" | "parent" | "relevance" | "include_slugs" | undefined;
         searchColumns?: string[] | undefined;
         slug?: string | string[] | undefined;
         taxRelation?: "AND" | "OR" | undefined;
@@ -169,7 +169,7 @@ declare const ROUTER_MAP: {
         excerpt: string | null;
         commentsEnabled: boolean;
         protected: boolean;
-        format: "image" | "link" | "standard" | "aside" | "chat" | "gallery" | "quote" | "status" | "video" | "audio";
+        format: "standard" | "aside" | "chat" | "gallery" | "link" | "image" | "quote" | "status" | "video" | "audio";
         sticky: boolean;
         author: {
           id: number;
@@ -299,12 +299,70 @@ declare const ROUTER_MAP: {
     }>;
   };
   seo: {
-    sitemaps: Procedure<"internal", {}, {
-      key: string;
-      type: "author" | "post_type" | "taxonomy";
-      pages: number;
-      lastmod: string;
-    }[], DefinedErrorMapLike>;
+    homepage: Procedure<"internal", {}, {
+      head: {
+        title: string;
+        canonical: string;
+        robots: {
+          index: string;
+          follow: string;
+          maxSnippet: string;
+          maxImagePreview: string;
+          maxVideoPreview: string;
+        };
+        og: {
+          locale: string;
+          type: string;
+          title: string;
+          url: string;
+          siteName: string;
+          description: string;
+          image: {
+            url: string;
+            width: string;
+            height: string;
+            type: string;
+            alt: string | null;
+          } | null;
+        };
+        twitter: {
+          card: "summary" | "summary_large_image";
+          title: string;
+          site: string | null;
+          creator: string | null;
+          description: string;
+          image: string | null;
+        };
+        article: {
+          publishedTime: string;
+          modifiedTime: string;
+          author: string;
+          authorUrl: string;
+          section: string;
+        } | null;
+      };
+      schema: {
+        "@context": "https://schema.org";
+        "@graph": Record<string, unknown>[];
+      };
+    }, DefinedErrorMapLike>;
+    sitemaps: {
+      list: Procedure<"internal", {}, {
+        key: string;
+        type: "author" | "post_type" | "taxonomy";
+        pages: number;
+        lastmod: string;
+      }[], DefinedErrorMapLike>;
+      index: Procedure<"internal", {}, {
+        origin: string;
+        sitemaps: {
+          key: string;
+          type: "author" | "post_type" | "taxonomy";
+          pages: number;
+          lastmod: string;
+        }[];
+      }, DefinedErrorMapLike>;
+    };
     robots: Procedure<"internal", {}, {
       sitemaps: string[];
       rules: {
@@ -342,7 +400,7 @@ declare const ROUTER_MAP: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "title" | "author" | "date" | "id" | "parent" | "slug" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "date" | "id" | "slug" | "title" | "author" | "include" | "parent" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: string[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -355,7 +413,7 @@ declare const ROUTER_MAP: {
           id: number;
           href: string;
           name: string;
-          type: "custom" | "page" | "post" | "category" | "product" | "product_cat" | "product_tag";
+          type: "custom" | "post" | "page" | "category" | "product" | "product_cat" | "product_tag";
           description: string;
           meta: {
             [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/any | {
@@ -413,7 +471,7 @@ declare const ROUTER_MAP: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "title" | "author" | "date" | "id" | "parent" | "slug" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "date" | "id" | "slug" | "title" | "author" | "include" | "parent" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: string[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -503,7 +561,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "parent" | "post" | "include" | undefined;
+        orderby?: "date" | "id" | "post" | "include" | "parent" | undefined;
         parent?: string | number | (string | number)[] | undefined;
         parentExclude?: string | number | (string | number)[] | undefined;
         post?: string | number | (string | number)[] | undefined;

package/dist/seo/index.js

@@ -1,20 +1,85 @@
 import { createProcedure } from "../shared/procedure.js";
 import { WP_KIZLO_BASE } from "../wordpress/constants.js";
-import { ListSitemapUrlInput, Robots, SitemapList, SitemapUrlList } from "./schema.js";
+import { ListSitemapUrlInput, Robots, Seo, SitemapIndex, SitemapList, SitemapUrlList } from "./schema.js";
 
 //#region src/seo/index.ts
 const SEO_ROUTER_MAP = {
-	sitemaps: createProcedure({
+	homepage: createProcedure({
 		scope: "internal",
-		output: SitemapList
+		output: Seo
 	}, async ({ context, errors }) => {
-		const response = await context.service.wordpress.get("/seo/sitemaps", { base: WP_KIZLO_BASE });
+		const response = await context.service.wordpress.get("/seo/homepage", { base: WP_KIZLO_BASE });
 		if (response.error) {
-			context.logger.error("List sitemaps unhandled error", response.error);
+			context.logger.error("Get homepage seo unhandled error", response.error);
 			throw errors.INTERNAL_SERVER_ERROR();
 		}
-		return response.data;
+		const { head } = response.data;
+		return {
+			head: {
+				title: head.title,
+				canonical: head.canonical,
+				robots: {
+					index: head.robots.index,
+					follow: head.robots.follow,
+					maxSnippet: head.robots["max-snippet"],
+					maxImagePreview: head.robots["max-image-preview"],
+					maxVideoPreview: head.robots["max-video-preview"]
+				},
+				og: {
+					locale: head.og.locale,
+					type: head.og.type,
+					title: head.og.title,
+					url: head.og.url,
+					siteName: head.og.site_name,
+					description: head.og.description ?? "",
+					image: head.og.image
+				},
+				twitter: {
+					card: head.twitter.card,
+					title: head.twitter.title,
+					site: head.twitter.site,
+					creator: head.twitter.creator,
+					description: head.twitter.description ?? "",
+					image: head.twitter.image
+				},
+				article: head.article && {
+					publishedTime: head.article.published_time,
+					modifiedTime: head.article.modified_time,
+					author: head.article.author,
+					authorUrl: head.article.author_url,
+					section: head.article.section
+				}
+			},
+			schema: response.data.schema
+		};
 	}),
+	sitemaps: {
+		list: createProcedure({
+			scope: "internal",
+			output: SitemapList
+		}, async ({ context, errors }) => {
+			const response = await context.service.wordpress.get("/seo/sitemaps", { base: WP_KIZLO_BASE });
+			if (response.error) {
+				context.logger.error("List sitemaps unhandled error", response.error);
+				throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return response.data;
+		}),
+		index: createProcedure({
+			scope: "internal",
+			output: SitemapIndex
+		}, async ({ context, errors }) => {
+			const response = await context.service.wordpress.get("/seo/sitemaps/index", { base: WP_KIZLO_BASE });
+			if (response.error) {
+				context.logger.error("Get sitemap index unhandled error", response.error);
+				throw errors.INTERNAL_SERVER_ERROR();
+			}
+			return {
+				origin: response.data.origin,
+				sitemaps: response.data.sitemaps
+			};
+		})
+	},
 	robots: createProcedure({
 		scope: "internal",
 		output: Robots

package/dist/seo/robots.js

@@ -0,0 +1,18 @@
+//#region src/seo/robots.ts
+function createRobotsRoute(client) {
+	return async function GET(_request) {
+		const data = await client.seo.robots.call();
+		const groups = data.rules.map((rule) => {
+			const lines = [`User-agent: ${rule.userAgent}`];
+			for (const path of rule.allow) lines.push(`Allow: ${path}`);
+			for (const path of rule.disallow) lines.push(`Disallow: ${path}`);
+			return lines.join("\n");
+		});
+		const sitemaps = data.sitemaps.map((url) => `Sitemap: ${url}`).join("\n");
+		const blocks = [groups.join("\n\n"), sitemaps].filter(Boolean);
+		return new Response(`${blocks.join("\n\n")}\n`, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+	};
+}
+
+//#endregion
+export { createRobotsRoute };

package/dist/seo/schema.d.ts

@@ -131,6 +131,20 @@ declare const SitemapList: z.ZodArray<z.ZodObject<{
   lastmod: z.ZodString;
 }, z.core.$strip>>;
 type SitemapList = z.infer<typeof SitemapList>;
+declare const SitemapIndex: z.ZodObject<{
+  origin: z.ZodString;
+  sitemaps: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodEnum<{
+      author: "author";
+      post_type: "post_type";
+      taxonomy: "taxonomy";
+    }>;
+    pages: z.ZodNumber;
+    lastmod: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SitemapIndex = z.infer<typeof SitemapIndex>;
 declare const SitemapUrlImage: z.ZodObject<{
   loc: z.ZodString;
   title: z.ZodString;
@@ -193,4 +207,4 @@ declare const Robots: z.ZodObject<{
 }, z.core.$strip>;
 type Robots = z.infer<typeof Robots>;
 //#endregion
-export { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList };
+export { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList };

package/dist/seo/schema.js

@@ -64,6 +64,10 @@ const Sitemap = z.object({
 	lastmod: z.string()
 });
 const SitemapList = z.array(Sitemap);
+const SitemapIndex = z.object({
+	origin: z.string(),
+	sitemaps: SitemapList
+});
 const SitemapUrlImage = z.object({
 	loc: z.string(),
 	title: z.string()
@@ -93,4 +97,4 @@ const Robots = z.object({
 });
 
 //#endregion
-export { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList };
+export { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList };

package/dist/seo/sitemap.d.ts

@@ -0,0 +1,39 @@
+import { SitemapUrl } from "./schema.js";
+import { SitemapIndexEntry } from "./utils.js";
+import { S2SClient } from "../kizlo.js";
+
+//#region src/seo/sitemap.d.ts
+
+/**
+ * Every generated sitemap is served from `/sitemaps`: the index at `/sitemaps/index.xml`
+ * and each collection page at `/sitemaps/{key}.xml` (later pages `-{n}`). The base is fixed
+ * because the index `<loc>` entries (built by `sitemapEntryPath`) point at it, so the route
+ * must be mounted there for the links to resolve. How the route is mounted is a
+ * framework concern; this handler only cares about the trailing slug.
+ */
+declare const SITEMAP_BASE = "/sitemaps";
+/** Slug that serves the sitemap index (`/sitemaps/index.xml`) rather than a collection. */
+declare const SITEMAP_INDEX_SLUG = "index.xml";
+/**
+ * A sitemap not backed by WordPress (e.g. docs pages living in the app). It joins the
+ * same index/urlset pipeline: `entry` adds it to the index, `urls` serves its pages.
+ */
+interface SitemapRouteExtra {
+  entry: SitemapIndexEntry;
+  urls: (origin: string, page: number) => SitemapUrl[] | Promise<SitemapUrl[]>;
+}
+interface CreateSitemapRouteOptions {
+  /** Extra, non-WordPress sitemaps to fold into the index and serve. */
+  extra?: SitemapRouteExtra[];
+}
+/**
+ * Builds a Web `Request` -> `Response` handler that serves the sitemap index
+ * (`/sitemaps/index.xml`) and every collection page, merging any `extra` sitemaps in.
+ * Framework-agnostic: the slug is the last path segment of the request URL, so this runs
+ * as-is on any web-standard server (Hono, a plain fetch handler, a Next route handler).
+ * Mounting it at the right path is the caller's job; framework wrappers (e.g. the Next
+ * integration) add mount assertions on top.
+ */
+declare function createSitemapRoute(client: S2SClient<[]>, options?: CreateSitemapRouteOptions): (request: Request) => Promise<Response>;
+//#endregion
+export { CreateSitemapRouteOptions, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SitemapRouteExtra, createSitemapRoute };