kizlo 0.2.1 → 0.3.0

package/README.md

@@ -11,10 +11,10 @@
   </a>
 </p>
 
-<h3 align="center">Headless WordPress Toolkit</h3>
+<h3 align="center">Headless WordPress Toolkit for TypeScript</h3>
 
 <p align="center">
-  Your backend, your frontend — Kizlo handles the plumbing.
+  Develop, test, and ship from your machine with a fully typed RPC layer and WordPress API client.
 </p>
 
 <p align="center">
@@ -34,7 +34,9 @@
 
 ## What is Kizlo?
 
-Kizlo is a framework-agnostic toolkit for headless WordPress, built for a stack you host and own from top to bottom. Use it to build websites, mobile apps, agentic applications, and more — Kizlo takes care of the plumbing so you can focus on the design.
+Kizlo is an open-source, typesafe toolkit for headless WordPress, built to sit behind any JavaScript framework as your backend or CMS. Its CLI spins up a local, Docker-based environment scoped to your project, giving you a fully typed RPC layer and WordPress API client to develop, test, and ship from your machine.
+
+> Kizlo extends through integrations, whether that's a WordPress plugin like WooCommerce or an external service for auth, analytics, and more. Browse all available [integrations](https://kizlo.io/integrations).
 
 ## Quick start
 
@@ -44,23 +46,17 @@ Set up Kizlo in your project:
 npx kizlo@latest init
 ```
 
-Watch your extensions and regenerate the contract during development:
+Start the local WordPress stack and regenerate the contract as you work:
 
 ```bash
 npx kizlo dev
 ```
 
-Generate the contract once for production builds:
-
-```bash
-npx kizlo generate
-```
-
 See the [docs](https://kizlo.io/docs) for the full guide.
 
 ## Contributing
 
-Contributions are welcome — see [CONTRIBUTING.md](https://github.com/kizlo-io/kizlo/blob/main/CONTRIBUTING.md) for setup,
+Contributions are welcome. See [CONTRIBUTING.md](https://github.com/kizlo-io/kizlo/blob/main/CONTRIBUTING.md) for setup,
 workflow, and PR guidelines.
 
 ## Security

package/dist/adapters/captcha.js

@@ -1,3 +1,5 @@
+import { hash, hmac } from "../shared/crypto.js";
+
 //#region src/adapters/captcha.ts
 /** Author a custom captcha adapter — types your verify function against the {@link CaptchaAdapter} contract. */
 function createCaptchaAdapter(adapter) {
@@ -72,14 +74,20 @@ function arkose(opts) {
 		})).json()).session_details?.solved === true;
 	};
 }
+const ALTCHA_ALGORITHMS = {
+	"SHA-256": "SHA-256",
+	"SHA-384": "SHA-384",
+	"SHA-512": "SHA-512"
+};
 function altcha(opts) {
 	return async ({ token }) => {
 		try {
-			const payload = JSON.parse(Buffer.from(token, "base64").toString("utf-8"));
-			const { createHmac, createHash } = await import("node:crypto");
-			const algo = payload.algorithm.toLowerCase().replace("-", "");
-			if (createHash(algo).update(`${payload.salt}${payload.number}`).digest("hex") !== payload.challenge) return false;
-			return createHmac(algo, opts.hmacKey).update(payload.challenge).digest("hex") === payload.signature;
+			const json = new TextDecoder().decode(Uint8Array.from(atob(token), (c) => c.charCodeAt(0)));
+			const payload = JSON.parse(json);
+			const algo = ALTCHA_ALGORITHMS[payload.algorithm.toUpperCase()];
+			if (!algo) return false;
+			if (await hash(`${payload.salt}${payload.number}`, algo) !== payload.challenge) return false;
+			return await hmac(opts.hmacKey, payload.challenge, algo) === payload.signature;
 		} catch {
 			return false;
 		}

package/dist/cli/commands/dev.js

@@ -7,10 +7,10 @@ import { bootstrapDev } from "../wp/dev.js";
 import { reapOrphans, registerSession, removeProjectContainers, spawnWatchdog, unregisterSession } from "../wp/session.js";
 import { syncSiteSettings } from "../wp/settings.js";
 import { devStack } from "../wp/stack.js";
-import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { defineCommand } from "citty";
+import { randomBytes } from "node:crypto";
 import { networkInterfaces } from "node:os";
 
 //#region src/cli/commands/dev.ts

package/dist/cli/commands/init.js

@@ -10,11 +10,11 @@ import { syncSiteSettings } from "../wp/settings.js";
 import { devStack } from "../wp/stack.js";
 import { PRESETS, detectPreset, getPreset } from "../presets/index.js";
 import z from "zod/v4";
-import { randomBytes } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
+import { randomBytes } from "node:crypto";
 
 //#region src/cli/commands/init.ts
 /** Production connection keys — what a real deploy needs, and what `.env.example` always lists. */
@@ -116,6 +116,35 @@ function orCancel(value) {
 	}
 	return value;
 }
+/**
+* The single overwrite policy for every scaffolded file: create it when absent, overwrite on
+* `--force`, and otherwise ask before clobbering an existing file (keeping it when the user
+* declines or when running non-interactively with `--yes`). Every scaffolded file routes through
+* here rather than deciding for itself, so new files inherit the same behavior for free.
+*/
+async function scaffoldFile(cwd, file, opts) {
+	const absPath = path.join(cwd, file.relPath);
+	const existed = fs.existsSync(absPath);
+	if (existed) {
+		let overwrite = opts.force;
+		if (!opts.force && !opts.yes) {
+			p.log.warn(`${file.label} already exists at ${file.relPath}`);
+			overwrite = orCancel(await p.confirm({
+				message: "Overwrite it?",
+				initialValue: true
+			}));
+		}
+		if (!overwrite) return "kept";
+	}
+	fs.mkdirSync(path.dirname(absPath), { recursive: true });
+	fs.writeFileSync(absPath, file.contents);
+	return existed ? "overwritten" : "created";
+}
+/** Report a {@link scaffoldFile} outcome in init's usual voice. */
+function reportScaffold(file, result, yes) {
+	if (result === "kept") p.log.info(`Kept existing ${file.label} (${file.relPath})${yes ? " — pass --force to overwrite" : ""}`);
+	else p.log.success(`${result === "overwritten" ? "Overwrote" : "Created"} ${file.label} (${file.relPath})`);
+}
 async function collectInteractively(ctx) {
 	let siteUrl;
 	let baseUrl;
@@ -193,7 +222,7 @@ async function collectInteractively(ctx) {
 		validate: validate(dirPath)
 	}));
 	let alias = "";
-	if (ctx.preset.routeHandler) {
+	if (ctx.preset.apiPath) {
 		const serverDir = path.join(dir.replace(/^\.\//, "").replace(/\/+$/, ""), "server");
 		const detected = detectImportAlias(ctx.cwd, serverDir)?.prefix;
 		alias = orCancel(await p.text({
@@ -230,7 +259,7 @@ function collectFromEnv(ctx) {
 		wpUsername: process.env.KIZLO_WORDPRESS_USERNAME?.trim() ?? "",
 		wpPassword: process.env.KIZLO_WORDPRESS_APPLICATION_PASSWORD?.trim() ?? "",
 		dir,
-		alias: ctx.preset.routeHandler ? aliasWithSlash(detectImportAlias(ctx.cwd, path.join(dir, "server"))?.prefix) : ""
+		alias: ctx.preset.apiPath ? aliasWithSlash(detectImportAlias(ctx.cwd, path.join(dir, "server"))?.prefix) : ""
 	};
 }
 function readPkg(pkgPath) {
@@ -434,52 +463,38 @@ const init = defineCommand({
 		const exampleBody = `${exampleEnv}\n# Point the app at a local dev stack (managed by \`kizlo dev\`) instead of the keys above:\n# KIZLO_TARGET=dev\n`;
 		const exampleCreated = writeFileIfAbsent(path.join(cwd, ".env.example"), exampleBody);
 		const dirRel = setup.dir.replace(/^\.\//, "").replace(/\/+$/, "");
-		const configCreated = writeFileIfAbsent(path.join(cwd, "kizlo.config.ts"), kizloConfigTemplate(dirRel, setup.alias, setup.devPath));
 		const serverDirRel = path.join(dirRel, "server");
-		const serverEntryRel = path.join(serverDirRel, "index.ts");
-		const serverPath = path.join(cwd, serverEntryRel);
-		const serverExisted = fs.existsSync(serverPath);
-		let wroteServer = !serverExisted || force;
-		if (serverExisted && !force && !yes) {
-			p.log.warn(`A Kizlo server instance already exists at ${serverEntryRel}`);
-			wroteServer = orCancel(await p.confirm({
-				message: "Overwrite it?",
-				initialValue: true
-			}));
-		}
-		if (wroteServer) {
-			fs.mkdirSync(path.dirname(serverPath), { recursive: true });
-			fs.writeFileSync(serverPath, preset.serverEntry());
-		}
-		const generatedDirRel = path.join(serverDirRel, "generated");
-		writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
-		writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
 		const clientUrl = setup.siteUrl && !sameOrigin(setup.siteUrl, setup.baseUrl) ? setup.baseUrl : void 0;
 		const scaffold = {
 			serverDirName: path.basename(serverDirRel),
+			serverEntryPath: path.join(serverDirRel, "index.ts"),
+			clientPath: path.join(dirRel, "client.ts"),
 			appDir: detectAppDir(cwd, hasSrcDir),
 			serverImport: (fromDir) => resolveModuleImport(cwd, serverDirRel, fromDir, setup.alias),
 			clientUrl
 		};
-		const clientRel = path.join(dirRel, "client.ts");
-		const clientCreated = writeFileIfAbsent(path.join(cwd, clientRel), preset.clientEntry(scaffold));
-		let routeRel;
-		let routeCreated = false;
-		if (preset.routeHandler) {
-			const route = preset.routeHandler(scaffold);
-			routeRel = route.path;
-			routeCreated = writeFileIfAbsent(path.join(cwd, route.path), route.contents);
-		}
+		const files = [{
+			label: "Kizlo config",
+			relPath: "kizlo.config.ts",
+			contents: kizloConfigTemplate(dirRel, setup.alias, setup.devPath)
+		}, ...preset.scaffolds(scaffold)];
+		const scaffolded = [];
+		for (const file of files) scaffolded.push({
+			file,
+			result: await scaffoldFile(cwd, file, {
+				force,
+				yes
+			})
+		});
+		const generatedDirRel = path.join(serverDirRel, "generated");
+		writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
+		writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
 		const gitignore = ensureGitignored(cwd, ".env");
 		if (!envExisted) p.log.success("Created .env");
 		else if (merge.updated.length || merge.added.length) p.log.success("Updated .env");
 		else p.log.info("Left .env unchanged");
 		p.log.success(exampleCreated ? "Created .env.example" : "Skipped .env.example (exists)");
-		p.log.success(configCreated ? "Created kizlo.config.ts" : "Skipped kizlo.config.ts (exists)");
-		if (wroteServer) p.log.success(`${serverExisted ? "Overwrote" : "Created"} Kizlo server instance (${serverEntryRel})`);
-		else p.log.info(`Kept existing Kizlo server instance (${serverEntryRel})${yes ? " — pass --force to overwrite" : ""}`);
-		p.log.success(clientCreated ? `Created browser client (${clientRel})` : "Skipped browser client (exists)");
-		if (routeRel) p.log.success(routeCreated ? `Created API route (${routeRel})` : "Skipped API route (exists)");
+		for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
 		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
 		if (setup.mode === "local") {
 			p.log.success(`Local WordPress configured (${setup.devPath}) — .env points at ${setup.wpUrl}`);

package/dist/cli/commands/test.js

@@ -5,6 +5,7 @@ import { isFree } from "../wp/ports.js";
 import { groupDefault, pickStackPort, withSpinner } from "../utils.js";
 import { resolveTestConfig } from "../daemon/config.js";
 import { testStack } from "../wp/stack.js";
+import { runPluginPhpunit } from "../wp/phpunit.js";
 import { runSeeds } from "../wp/setup.js";
 import { spawn } from "node:child_process";
 import { defineCommand } from "citty";
@@ -107,7 +108,9 @@ async function runSuite({ args }) {
 	log.info(cfg.command ? `Running: ${cfg.command}` : `Running: ${testCommand(cfg.packageManager).join(" ")}`);
 	let code = 1;
 	try {
-		code = await spawnTest(cfg.command, cfg.packageManager);
+		const jsCode = await spawnTest(cfg.command, cfg.packageManager);
+		const phpCode = await runPluginPhpunit(cfg);
+		code = jsCode !== 0 ? jsCode : phpCode;
 	} finally {
 		if (args.teardown) await withSpinner("Tearing down WordPress test stack", () => stack.composeDown(), "WordPress test stack stopped");
 		else log.info("Stack left running for fast reruns — `kizlo test stop` to stop it, or rerun with --teardown.");

package/dist/cli/presets/base.js

@@ -4,27 +4,35 @@ const base = {
 	label: "Generic (no framework detected)",
 	detect: () => 1,
 	baseUrlEnvKey: "KIZLO_BACKEND_URL",
-	serverEntry() {
-		return `import { createKizlo } from "kizlo"
+	scaffolds(ctx) {
+		return [{
+			label: "Kizlo server instance",
+			relPath: ctx.serverEntryPath,
+			contents: `import { createKizlo } from "kizlo"
 
 export const { router, client, context, handler } = createKizlo()
-`;
-	},
-	clientEntry(ctx) {
-		if (ctx.clientUrl) return `import { createKizloClient } from "kizlo"
+`
+		}, {
+			label: "Browser client",
+			relPath: ctx.clientPath,
+			contents: clientEntry(ctx)
+		}];
+	}
+};
+function clientEntry(ctx) {
+	if (ctx.clientUrl) return `import { createKizloClient } from "kizlo"
 import { contract } from "./${ctx.serverDirName}/generated"
 
 // Your Kizlo backend runs on a different origin than this app. Swap in your bundler's
 // public env var (e.g. import.meta.env.VITE_KIZLO_BACKEND_URL) to set it per environment.
 export const client = createKizloClient(contract, { url: "${ctx.clientUrl}" })
 `;
-		return `import { createKizloClient } from "kizlo"
+	return `import { createKizloClient } from "kizlo"
 import { contract } from "./${ctx.serverDirName}/generated"
 
 export const client = createKizloClient(contract)
 `;
-	}
-};
+}
 
 //#endregion
 export { base };

package/dist/cli/presets/nextjs.js

@@ -10,28 +10,75 @@ const nextjs = {
 	},
 	baseUrlEnvKey: "NEXT_PUBLIC_KIZLO_BACKEND_URL",
 	apiPath: "/api/kizlo",
-	serverEntry() {
-		return `import { createKizlo } from "kizlo/nextjs/server"
+	scaffolds(ctx) {
+		const apiDir = `${ctx.appDir}/api/kizlo/[[...rest]]`;
+		const robotsDir = `${ctx.appDir}/robots.txt`;
+		const sitemapDir = `${ctx.appDir}/sitemaps/[sitemap]`;
+		return [
+			{
+				label: "Kizlo server instance",
+				relPath: ctx.serverEntryPath,
+				contents: `import { createKizlo } from "kizlo/nextjs/server"
 
 export const { router, client, context, handler } = createKizlo()
-`;
-	},
-	clientEntry(ctx) {
-		return `import { createKizloClient } from "kizlo/nextjs"
+`
+			},
+			{
+				label: "Browser client",
+				relPath: ctx.clientPath,
+				contents: `import { createKizloClient } from "kizlo/nextjs"
 import { contract } from "./${ctx.serverDirName}/generated"
 
 export const client = createKizloClient(contract)
-`;
-	},
-	routeHandler(ctx) {
-		const dir = `${ctx.appDir}/api/kizlo/[[...rest]]`;
-		return {
-			path: `${dir}/route.ts`,
-			contents: `import { handler } from "${ctx.serverImport(dir)}"
+`
+			},
+			{
+				label: "API route",
+				relPath: `${apiDir}/route.ts`,
+				contents: `import { handler } from "${ctx.serverImport(apiDir)}"
 
 export { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE, handler as OPTIONS }
 `
-		};
+			},
+			{
+				label: "robots.txt route",
+				relPath: `${robotsDir}/route.ts`,
+				contents: `import { createRobotsRoute } from "kizlo/nextjs/server"
+import { client } from "${ctx.serverImport(robotsDir)}"
+
+// Run on the edge: cheaper and faster than Node for a response this small.
+export const runtime = "edge"
+
+// Vercel treats special metadata files like robots.txt and sitemap.xml as completely static
+// files at build time, bypassing normal Incremental Static Regeneration (ISR) and on-demand
+// revalidatePath rules.
+//
+// While your revalidation logic executes perfectly in a local Node.js server, Vercel uploads
+// these routes directly to its Edge CDN as immutable assets. Subsequent on-demand revalidation
+// triggers will successfully clear the Data Cache but fail to purge the CDN-level Edge cache
+// for that file.
+//
+// force-dynamic opts out of that static treatment so CMS edits show up; the WordPress call is
+// cached, so requests stay cheap.
+export const dynamic = "force-dynamic"
+
+export const GET = createRobotsRoute(client)
+`
+			},
+			{
+				label: "sitemap route",
+				relPath: `${sitemapDir}/route.ts`,
+				contents: `import { createSitemapRoute } from "kizlo/nextjs/server"
+import { client } from "${ctx.serverImport(sitemapDir)}"
+
+// Unlike robots.txt, Vercel revalidates this route on demand, so it can stay static. It's
+// served from the CDN at no per-request cost and still refreshes when content changes.
+export const dynamic = "force-static"
+
+export const GET = createSitemapRoute(client)
+`
+			}
+		];
 	}
 };
 

package/dist/cli/wp/dev.js

@@ -4,9 +4,9 @@ import { DEFAULT_PLUGINS, TEST_ADMIN } from "./constants.js";
 import { ensurePlugins } from "./utils.js";
 import { createAdminAppPassword, seedUsers } from "./bootstrap.js";
 import { prepareByo } from "./byo.js";
-import { randomBytes } from "node:crypto";
 import { existsSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { randomBytes } from "node:crypto";
 
 //#region src/cli/wp/dev.ts
 /** A strong random admin password (144 bits, URL/JSON/CLI-safe characters). */

package/dist/cli/wp/phpunit.js

@@ -0,0 +1,104 @@
+import { isLocalPlugin } from "./types.js";
+import { compose } from "./docker.js";
+import { log } from "../daemon/logger.js";
+import { existsSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+
+//#region src/cli/wp/phpunit.ts
+const PLUGINS_DIR = `/var/www/html/wp-content/plugins`;
+/** Isolated database the PHP suite runs against — never the served site's DB. */
+const TEST_DB = "wordpress_test";
+/** Root creds from the compose file, used only to create the DB and grant access. */
+const MYSQL_ROOT_PASSWORD = "rootpass";
+/** The app user the served site already connects as; the suite reuses it. */
+const MYSQL_USER = "wordpress";
+/**
+* The bind-mounted local plugins that carry a `phpunit.xml` (or `.dist`), resolved
+* to their in-container plugin dir. Checked on the host (where the source lives),
+* run in the container (where WordPress lives) — so this works identically for a
+* consumer whose own plugin is mounted while kizlo comes from a release.
+*/
+function phpunitTargets(cfg) {
+	const seen = /* @__PURE__ */ new Set();
+	const targets = [];
+	for (const plugin of cfg.fixtures.flatMap((fixture) => fixture.plugins ?? [])) {
+		if (!isLocalPlugin(plugin)) continue;
+		const hostDir = isAbsolute(plugin.path) ? plugin.path : resolve(cfg.configDir, plugin.path);
+		const slug = basename(hostDir);
+		if (seen.has(slug)) continue;
+		seen.add(slug);
+		if (!(existsSync(resolve(hostDir, "phpunit.xml")) || existsSync(resolve(hostDir, "phpunit.xml.dist")))) continue;
+		if (!existsSync(resolve(hostDir, "vendor/bin/phpunit"))) {
+			log.warn(`${slug} has a phpunit config but no vendor/bin/phpunit — run \`composer install\` with dev dependencies to run its PHP tests. Skipping.`);
+			continue;
+		}
+		targets.push({
+			slug,
+			containerDir: `${PLUGINS_DIR}/${slug}`
+		});
+	}
+	return targets;
+}
+/**
+* Create the isolated `wordpress_test` database in the `mysql` service and grant the
+* app user full access to it. Idempotent (`IF NOT EXISTS` + a re-runnable grant), so
+* it can run on every `kizlo test` next to seeding without a guard.
+*/
+async function provisionTestDb() {
+	const sql = [
+		`CREATE DATABASE IF NOT EXISTS ${TEST_DB};`,
+		`GRANT ALL PRIVILEGES ON ${TEST_DB}.* TO '${MYSQL_USER}'@'%';`,
+		"FLUSH PRIVILEGES;"
+	].join(" ");
+	const res = await compose([
+		"exec",
+		"-T",
+		"mysql",
+		"mysql",
+		`-uroot`,
+		`-p${MYSQL_ROOT_PASSWORD}`,
+		"-e",
+		sql
+	]);
+	if (res.code !== 0) throw new Error(`Failed to provision the ${TEST_DB} database:\n${res.stderr || res.stdout}`);
+}
+/** Run one plugin's phpunit suite inside the `wordpress` container; resolve its exit code. */
+async function runTarget(target) {
+	const wpPhpunitDir = `${target.containerDir}/vendor/wp-phpunit/wp-phpunit`;
+	const res = await compose([
+		"exec",
+		"-T",
+		"-w",
+		target.containerDir,
+		"-e",
+		`WP_PHPUNIT__DIR=${wpPhpunitDir}`,
+		"wordpress",
+		"php",
+		"vendor/bin/phpunit",
+		"--colors=always"
+	]);
+	process.stdout.write(res.stdout);
+	if (res.stderr) process.stderr.write(res.stderr);
+	return res.code;
+}
+/**
+* Provision the test DB, then run phpunit for every bind-mounted local plugin that
+* ships a phpunit config. Returns the worst exit code (0 when nothing to run), so the
+* caller can fold PHP results into the overall `kizlo test` outcome. Plugin-agnostic:
+* it never hardcodes `plugins/kizlo`.
+*/
+async function runPluginPhpunit(cfg) {
+	const targets = phpunitTargets(cfg);
+	if (targets.length === 0) return 0;
+	await provisionTestDb();
+	let worst = 0;
+	for (const target of targets) {
+		log.info(`Running PHP tests for ${target.slug}…`);
+		const code = await runTarget(target);
+		if (code !== 0) worst = code;
+	}
+	return worst;
+}
+
+//#endregion
+export { runPluginPhpunit };

package/dist/context.js

@@ -1,8 +1,8 @@
+import { compare, hmac } from "./shared/crypto.js";
 import { noopAdapter } from "./adapters/logger.js";
 import { PreviewTokenData } from "./shared/schema.js";
 import { CookiesStorage } from "./cookie.js";
 import { Service } from "./service.js";
-import { compare, hmac } from "./shared/crypto.js";
 import { base64Decode, tryCatchSync } from "@kizlo/shared";
 import { serialize } from "cookie";
 
@@ -106,7 +106,7 @@ var Context = class {
 			if (error) return null;
 			if (Date.now() > data.payload.expires * 1e3) return null;
 			const payloadStr = `${data.payload.id}.${data.payload.parent}.${data.payload.expires}`;
-			if (!compare(hmac(this.config.siteSecret ?? "", payloadStr), data.hash)) return null;
+			if (!await compare(await hmac(this.config.siteSecret ?? "", payloadStr), data.hash)) return null;
 			return data.payload;
 		};
 	}

package/dist/index.d.ts

@@ -17,6 +17,9 @@ import "./wordpress/index.js";
 import { DevPluginSource, Fixture, FixtureCleanupFn, FixtureSeedFn, JsonValue, LocalPlugin, PluginSource, SeedContext, TestAdminUser, TestCredentials, TestUser, defineFixture, isLocalPlugin } from "./cli/wp/types.js";
 import { AuthAdapter, AuthGetUser, AuthUser, authMock, createAuthAdapter } from "./adapters/auth.js";
 import { CaptchaAdapter, altcha, arkose, createCaptchaAdapter, friendlyCaptcha, hcaptcha, recaptcha, turnstile } from "./adapters/captcha.js";
+import { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList } from "./seo/schema.js";
+import { WPK_ListSitemapUrlInput, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage } from "./seo/types.js";
+import { SitemapIndexEntry } from "./seo/utils.js";
 import { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, Media, PreviewTokenData, PreviewTokenPayload } from "./shared/schema.js";
 import { AnyContext, AnyNestedClient, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, HTTPMethod, List, MaybeOptionalOptions, RedirectInput, RedirectStatus } from "./shared/types.js";
 import { createCookiesAdapter } from "./adapters/cookies.js";
@@ -34,11 +37,10 @@ import { AuthUserFn, ConnInfoFn, Context, ContextConfig, ServerContext, VerifyCa
 import { AnyMiddleware, ExtractMiddlewareContextOutput, InferUses, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, createMiddleware } from "./shared/middleware.js";
 import { AnyProcedure, AnyProcedureRouter, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType } from "./shared/procedure.js";
 import { KizloClient, KizloClientConfig, createKizloClient } from "./client.js";
-import { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList } from "./seo/schema.js";
-import { WPK_ListSitemapUrlInput, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapUrl, WPK_SitemapUrlImage } from "./seo/types.js";
+import { CreateSitemapRouteOptions, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SitemapRouteExtra, createSitemapRoute } from "./seo/sitemap.js";
 import { Contract, ContractProcedure, generateContract, isContractProcedure, restoreContract } from "./shared/contract.js";
-import { compare, hash, hmac } from "./shared/crypto.js";
+import { ShaAlgorithm, compare, hash, hmac } from "./shared/crypto.js";
 import { Identifier, parseIdentifier } from "./shared/identifier.js";
 import { createOrpcRouter } from "./shared/router.js";
 import { deserializeCurrencyFormat, deserializeListMetadata, emptyList, serializeCurrencyFormat } from "./shared/serialize.js";
-export { AnyContext, AnyEventSchema, AnyEvents, AnyExtension, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureRouter, AuthAdapter, AuthGetUser, AuthUser, AuthUserFn, BaseHandlerOptions, CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CaptchaAdapter, CommentService, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CreateKizloOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, Environment, ErrorDefinition, EventHandler, EventHandlerFn, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtractExtensionRouter, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, Identifier, IdentifierInput, InferEventUnion, InferExtensionRouter, InferUses, InvocationScope, JsonValue, Kizlo, KizloAuthorsSettings, KizloAuthorsSettingsInput, KizloClient, KizloClientConfig, KizloConfig, KizloCrawlingSettings, KizloCrawlingSettingsInput, KizloError, KizloErrorOptions, KizloIdentitySettings, KizloIdentitySettingsInput, KizloMedia, KizloOrganizationFounder, KizloOrganizationSettings, KizloOrganizationSettingsInput, KizloPersonSettings, KizloPersonSettingsInput, KizloPostStatus, KizloPostTypeSettings, KizloPostTypeSettingsInput, KizloSettings, KizloSettingsService, KizloSiteSettings, KizloSiteSettingsInput, KizloSocialProfile, KizloTarget, KizloTaxonomySettings, KizloTaxonomySettingsInput, KizloWebhookSettings, KizloWebhookSettingsInput, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, MaybeOptionalOptions, Media, MenuItemService, MenuService, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, PluginSource, PostService, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, Robots, RobotsRule, RootRouter, RouterDepthTuple, S2SClient, SAFE_REQUEST_TIMEOUT, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServerContext, Service, ServiceAdapters, ServiceConfig, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UNEXPECTED_BODY_SNIPPET_LENGTH, UserService, VerifyCaptchaFn, VerifyPreviewTokenFn, WC_CORE_BASE, WC_STORE_BASE, WPK_ListSitemapUrlInput, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CORE_BASE, WP_Comment, WP_CommentAvatarUrls, WP_CommentContent, WP_CommentContentInput, WP_CommentCreateErrorCode, WP_CommentCreateInput, WP_CommentDeleteErrorCode, WP_CommentDeleteInput, WP_CommentDeleteResponse, WP_CommentLinks, WP_CommentListErrorCode, WP_CommentListInput, WP_CommentOrderBy, WP_CommentRetrieveErrorCode, WP_CommentRetrieveInput, WP_CommentStatus, WP_CommentStatusFilter, WP_CommentStatusInput, WP_CommentType, WP_CommentUpdateErrorCode, WP_CommentUpdateInput, WP_CommonErrorCode, WP_Context, WP_CurrencyFormat, WP_Error, WP_ErrorData, WP_KIZLO_BASE, WP_Link, WP_List, WP_ListMetadata, WP_ListOrder, WP_Menu, WP_MenuCreateErrorCode, WP_MenuCreateInput, WP_MenuDeleteErrorCode, WP_MenuDeleteInput, WP_MenuDeleteResponse, WP_MenuItem, WP_MenuItemCreateErrorCode, WP_MenuItemCreateInput, WP_MenuItemDeleteErrorCode, WP_MenuItemDeleteInput, WP_MenuItemDeleteResponse, WP_MenuItemLinks, WP_MenuItemListErrorCode, WP_MenuItemListInput, WP_MenuItemOrderBy, WP_MenuItemRetrieveErrorCode, WP_MenuItemRetrieveInput, WP_MenuItemStatus, WP_MenuItemStatusFilter, WP_MenuItemTarget, WP_MenuItemTaxRelation, WP_MenuItemTitle, WP_MenuItemTitleInput, WP_MenuItemType, WP_MenuItemUpdateErrorCode, WP_MenuItemUpdateInput, WP_MenuLinks, WP_MenuListErrorCode, WP_MenuListInput, WP_MenuOrderBy, WP_MenuRetrieveErrorCode, WP_MenuRetrieveInput, WP_MenuUpdateErrorCode, WP_MenuUpdateInput, WP_Post, WP_PostCommentStatus, WP_PostContent, WP_PostContentInput, WP_PostCreateErrorCode, WP_PostCreateInput, WP_PostDeleteErrorCode, WP_PostDeleteInput, WP_PostDeleteResponse, WP_PostExcerpt, WP_PostExcerptInput, WP_PostFormat, WP_PostGuid, WP_PostLinks, WP_PostListErrorCode, WP_PostListInput, WP_PostOrderBy, WP_PostRetrieveErrorCode, WP_PostRetrieveInput, WP_PostStatus, WP_PostStatusFilter, WP_PostTaxRelation, WP_PostTitle, WP_PostTitleInput, WP_PostUpdateErrorCode, WP_PostUpdateInput, WP_RequestInput, WP_Result, WP_User, WP_UserAvatarUrls, WP_UserCapabilities, WP_UserCreateErrorCode, WP_UserCreateInput, WP_UserDeleteErrorCode, WP_UserDeleteInput, WP_UserDeleteMeErrorCode, WP_UserDeleteMeInput, WP_UserDeleteMeResponse, WP_UserDeleteResponse, WP_UserLinks, WP_UserListErrorCode, WP_UserListInput, WP_UserOrderBy, WP_UserRetrieveErrorCode, WP_UserRetrieveInput, WP_UserRetrieveMeErrorCode, WP_UserRetrieveMeInput, WP_UserUpdateErrorCode, WP_UserUpdateInput, WP_UserUpdateMeErrorCode, WP_UserUpdateMeInput, WP_UserWho, WebhookOptions, WithCommonErrorMap, WordPressCredentials, WordPressService, altcha, arkose, authMock, buildProcedure, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createMiddleware, createOrpcRouter, createProcedure, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, recaptcha, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, toKizloError, turnstile };
+export { AnyContext, AnyEventSchema, AnyEvents, AnyExtension, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureRouter, AuthAdapter, AuthGetUser, AuthUser, AuthUserFn, BaseHandlerOptions, CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CaptchaAdapter, CommentService, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, Environment, ErrorDefinition, EventHandler, EventHandlerFn, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtractExtensionRouter, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, Identifier, IdentifierInput, InferEventUnion, InferExtensionRouter, InferUses, InvocationScope, JsonValue, Kizlo, KizloAuthorsSettings, KizloAuthorsSettingsInput, KizloClient, KizloClientConfig, KizloConfig, KizloCrawlingSettings, KizloCrawlingSettingsInput, KizloError, KizloErrorOptions, KizloIdentitySettings, KizloIdentitySettingsInput, KizloMedia, KizloOrganizationFounder, KizloOrganizationSettings, KizloOrganizationSettingsInput, KizloPersonSettings, KizloPersonSettingsInput, KizloPostStatus, KizloPostTypeSettings, KizloPostTypeSettingsInput, KizloSettings, KizloSettingsService, KizloSiteSettings, KizloSiteSettingsInput, KizloSocialProfile, KizloTarget, KizloTaxonomySettings, KizloTaxonomySettingsInput, KizloWebhookSettings, KizloWebhookSettingsInput, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, MaybeOptionalOptions, Media, MenuItemService, MenuService, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, PluginSource, PostService, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, Robots, RobotsRule, RootRouter, RouterDepthTuple, S2SClient, SAFE_REQUEST_TIMEOUT, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServerContext, Service, ServiceAdapters, ServiceConfig, ShaAlgorithm, Sitemap, SitemapIndex, type SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UNEXPECTED_BODY_SNIPPET_LENGTH, UserService, VerifyCaptchaFn, VerifyPreviewTokenFn, WC_CORE_BASE, WC_STORE_BASE, WPK_ListSitemapUrlInput, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CORE_BASE, WP_Comment, WP_CommentAvatarUrls, WP_CommentContent, WP_CommentContentInput, WP_CommentCreateErrorCode, WP_CommentCreateInput, WP_CommentDeleteErrorCode, WP_CommentDeleteInput, WP_CommentDeleteResponse, WP_CommentLinks, WP_CommentListErrorCode, WP_CommentListInput, WP_CommentOrderBy, WP_CommentRetrieveErrorCode, WP_CommentRetrieveInput, WP_CommentStatus, WP_CommentStatusFilter, WP_CommentStatusInput, WP_CommentType, WP_CommentUpdateErrorCode, WP_CommentUpdateInput, WP_CommonErrorCode, WP_Context, WP_CurrencyFormat, WP_Error, WP_ErrorData, WP_KIZLO_BASE, WP_Link, WP_List, WP_ListMetadata, WP_ListOrder, WP_Menu, WP_MenuCreateErrorCode, WP_MenuCreateInput, WP_MenuDeleteErrorCode, WP_MenuDeleteInput, WP_MenuDeleteResponse, WP_MenuItem, WP_MenuItemCreateErrorCode, WP_MenuItemCreateInput, WP_MenuItemDeleteErrorCode, WP_MenuItemDeleteInput, WP_MenuItemDeleteResponse, WP_MenuItemLinks, WP_MenuItemListErrorCode, WP_MenuItemListInput, WP_MenuItemOrderBy, WP_MenuItemRetrieveErrorCode, WP_MenuItemRetrieveInput, WP_MenuItemStatus, WP_MenuItemStatusFilter, WP_MenuItemTarget, WP_MenuItemTaxRelation, WP_MenuItemTitle, WP_MenuItemTitleInput, WP_MenuItemType, WP_MenuItemUpdateErrorCode, WP_MenuItemUpdateInput, WP_MenuLinks, WP_MenuListErrorCode, WP_MenuListInput, WP_MenuOrderBy, WP_MenuRetrieveErrorCode, WP_MenuRetrieveInput, WP_MenuUpdateErrorCode, WP_MenuUpdateInput, WP_Post, WP_PostCommentStatus, WP_PostContent, WP_PostContentInput, WP_PostCreateErrorCode, WP_PostCreateInput, WP_PostDeleteErrorCode, WP_PostDeleteInput, WP_PostDeleteResponse, WP_PostExcerpt, WP_PostExcerptInput, WP_PostFormat, WP_PostGuid, WP_PostLinks, WP_PostListErrorCode, WP_PostListInput, WP_PostOrderBy, WP_PostRetrieveErrorCode, WP_PostRetrieveInput, WP_PostStatus, WP_PostStatusFilter, WP_PostTaxRelation, WP_PostTitle, WP_PostTitleInput, WP_PostUpdateErrorCode, WP_PostUpdateInput, WP_RequestInput, WP_Result, WP_User, WP_UserAvatarUrls, WP_UserCapabilities, WP_UserCreateErrorCode, WP_UserCreateInput, WP_UserDeleteErrorCode, WP_UserDeleteInput, WP_UserDeleteMeErrorCode, WP_UserDeleteMeInput, WP_UserDeleteMeResponse, WP_UserDeleteResponse, WP_UserLinks, WP_UserListErrorCode, WP_UserListInput, WP_UserOrderBy, WP_UserRetrieveErrorCode, WP_UserRetrieveInput, WP_UserRetrieveMeErrorCode, WP_UserRetrieveMeInput, WP_UserUpdateErrorCode, WP_UserUpdateInput, WP_UserUpdateMeErrorCode, WP_UserUpdateMeInput, WP_UserWho, WebhookOptions, WithCommonErrorMap, WordPressCredentials, WordPressService, altcha, arkose, authMock, buildProcedure, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createMiddleware, createOrpcRouter, createProcedure, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, recaptcha, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, toKizloError, turnstile };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { authMock, createAuthAdapter } from "./adapters/auth.js";
+import { compare, hash, hmac } from "./shared/crypto.js";
 import { altcha, arkose, createCaptchaAdapter, friendlyCaptcha, hcaptcha, recaptcha, turnstile } from "./adapters/captcha.js";
 import { createCookiesAdapter } from "./adapters/cookies.js";
 import { createGeoAdapter, geoMock } from "./adapters/geo.js";
@@ -22,14 +23,14 @@ import { isWordPressResourceError } from "./wordpress/utils.js";
 import { WordPressService } from "./wordpress/service.js";
 import { KizloSettingsService } from "./settings/service.js";
 import { Service } from "./service.js";
-import { compare, hash, hmac } from "./shared/crypto.js";
 import { Context } from "./context.js";
 import { deserializeCurrencyFormat, deserializeListMetadata, emptyList, serializeCurrencyFormat } from "./shared/serialize.js";
 import { parseIdentifier } from "./shared/identifier.js";
-import { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList } from "./seo/schema.js";
+import { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList } from "./seo/schema.js";
 import { createEventHandler, createWebhookRouter } from "./webhook/index.js";
 import { Kizlo, createKizlo, resolveKizloConfig } from "./kizlo.js";
+import { SITEMAP_BASE, SITEMAP_INDEX_SLUG, createSitemapRoute } from "./seo/sitemap.js";
 import { createExtension } from "./shared/extension.js";
 import { createMiddleware } from "./shared/middleware.js";
 
-export { CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CommentService, ContentType, Context, CurrencyFormat, IdentifierInput, Kizlo, KizloClient, KizloError, KizloSettingsService, LIST_ORDER, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, Media, MenuItemService, MenuService, PostService, PreviewTokenData, PreviewTokenPayload, Robots, RobotsRule, SAFE_REQUEST_TIMEOUT, Seo, SeoHead, SeoSchema, Service, Sitemap, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, UNEXPECTED_BODY_SNIPPET_LENGTH, UserService, WC_CORE_BASE, WC_STORE_BASE, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CORE_BASE, WP_Error, WP_KIZLO_BASE, WordPressService, altcha, arkose, authMock, buildProcedure, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createMiddleware, createOrpcRouter, createProcedure, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, recaptcha, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, toKizloError, turnstile };
+export { CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CommentService, ContentType, Context, CurrencyFormat, IdentifierInput, Kizlo, KizloClient, KizloError, KizloSettingsService, LIST_ORDER, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, Media, MenuItemService, MenuService, PostService, PreviewTokenData, PreviewTokenPayload, Robots, RobotsRule, SAFE_REQUEST_TIMEOUT, SITEMAP_BASE, SITEMAP_INDEX_SLUG, Seo, SeoHead, SeoSchema, Service, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, UNEXPECTED_BODY_SNIPPET_LENGTH, UserService, WC_CORE_BASE, WC_STORE_BASE, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CORE_BASE, WP_Error, WP_KIZLO_BASE, WordPressService, altcha, arkose, authMock, buildProcedure, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createMiddleware, createOrpcRouter, createProcedure, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, recaptcha, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, toKizloError, turnstile };

package/dist/integrations/nextjs/kizlo.server.d.ts

@@ -1,12 +1,11 @@
 import { AnyExtension } from "../../shared/extension.js";
 import { CreateKizloOptions, Kizlo } from "../../kizlo.js";
+import { NextRevalidateOptions } from "./revalidate.js";
 
 //#region src/integrations/nextjs/kizlo.server.d.ts
-type KizloServerOptions<TExts extends readonly AnyExtension[] = []> = CreateKizloOptions<TExts>;
-/**
- * Creates a Kizlo server for Next.js — same as the base `createKizlo`, but reads
- * the public base URL from `NEXT_PUBLIC_KIZLO_BACKEND_URL`.
- */
-declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options?: CreateKizloOptions<TExts>): Kizlo<TExts>;
+type KizloServerOptions<TExts extends readonly AnyExtension[] = []> = CreateKizloOptions<TExts> & {
+  revalidate?: boolean | NextRevalidateOptions;
+};
+declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options?: KizloServerOptions<TExts>): Kizlo<TExts>;
 //#endregion
 export { KizloServerOptions, createKizlo };