kizlo 0.30.0 → 0.31.0

package/dist/integrations/tanstack-start/{react/cloudflare → cloudflare}/cache-policy.js

@@ -1,4 +1,4 @@
-//#region src/integrations/tanstack-start/react/cloudflare/cache-policy.ts
+//#region src/integrations/tanstack-start/cloudflare/cache-policy.ts
 const EDGE_HEADERS = [
 	"Cloudflare-CDN-Cache-Control",
 	"CDN-Cache-Control",
@@ -6,7 +6,6 @@ const EDGE_HEADERS = [
 ];
 function validateTags(tags) {
 	if (!Array.isArray(tags)) throw new TypeError("CDN tags must be an array of strings.");
-	if (tags.length > 1e3) throw new RangeError("At most 1000 explicit CDN tags are supported per response.");
 	for (const tag of tags) if (typeof tag !== "string" || !tag.length || tag.length > 1024 || /[^\x21-\x2b\x2d-\x7e]/.test(tag)) throw new TypeError("CDN tags must contain 1-1024 printable ASCII characters without spaces or commas.");
 	return [...new Set(tags)];
 }

package/dist/integrations/tanstack-start/{react/cloudflare → cloudflare}/cache.d.ts

@@ -1,6 +1,7 @@
 import { Duration } from "@kizlo/shared";
 
-//#region src/integrations/tanstack-start/react/cloudflare/cache.d.ts
+//#region src/integrations/tanstack-start/cloudflare/cache.d.ts
+
 interface CloudflareCacheResult {
   success: boolean;
   errors?: {
@@ -14,6 +15,9 @@ interface CloudflareCacheBinding {
     tags?: string[];
     pathPrefixes?: string[];
   }): Promise<CloudflareCacheResult>;
+  purge?(options: {
+    purgeEverything: true;
+  }): Promise<CloudflareCacheResult>;
 }
 interface CdnHeadersOptions {
   /** Freshness in seconds at the edge. Browser reuse requires revalidation. */
@@ -30,5 +34,7 @@ declare function createCdnHeaders(options: CdnHeadersOptions): Record<string, st
 declare function revalidateUrl(url: string | URL): Promise<void>;
 /** Mark responses carrying this host-scoped tag stale under their stored cache policy. */
 declare function revalidateTag(tag: string): Promise<void>;
+/** Remove every cached response owned by the calling Worker entrypoint. */
+declare function purgeCache(): Promise<void>;
 //#endregion
-export { CdnHeadersOptions, CloudflareCacheBinding, CloudflareCacheResult, createCdnHeaders, revalidateTag, revalidateUrl };
+export { CdnHeadersOptions, CloudflareCacheBinding, CloudflareCacheResult, createCdnHeaders, purgeCache, revalidateTag, revalidateUrl };

package/dist/integrations/tanstack-start/{react/cloudflare → cloudflare}/cache.js

@@ -3,7 +3,7 @@ import { EDGE_HEADERS, validateTags } from "./cache-policy.js";
 import { seconds } from "@kizlo/shared";
 import { createHash } from "node:crypto";
 
-//#region src/integrations/tanstack-start/react/cloudflare/cache.ts
+//#region src/integrations/tanstack-start/cloudflare/cache.ts
 function getCacheContext() {
 	const context = getStartRequestContext();
 	const cache = (context?.values)?.executionCtx?.cache;
@@ -47,13 +47,25 @@ async function revalidateUrl(url) {
 }
 /** Mark responses carrying this host-scoped tag stale under their stored cache policy. */
 async function revalidateTag(tag) {
+	await revalidateTags([tag]);
+}
+/** Submit every dependency, independently of the response storage budget. */
+async function revalidateTags(tags) {
+	const unique = validateTags(tags);
 	const state = getCacheContext();
-	validateTags([tag]);
-	await invalidate(state.cache, { tags: [resourceTag(state.url, tag)] });
+	for (let index = 0; index < unique.length; index += 100) await invalidate(state.cache, { tags: unique.slice(index, index + 100).map((tag) => resourceTag(state.url, tag)) });
+}
+/** Remove every cached response owned by the calling Worker entrypoint. */
+async function purgeCache() {
+	const { cache } = getCacheContext();
+	if (typeof cache.purge !== "function") throw new Error("The Worker runtime does not support cache.purge().");
+	assertCacheResult(await cache.purge({ purgeEverything: true }));
 }
 async function invalidate(cache, targets) {
 	if (typeof cache.invalidate !== "function") throw new Error("The Worker runtime does not support cache.invalidate().");
-	const result = await cache.invalidate(targets);
+	assertCacheResult(await cache.invalidate(targets));
+}
+function assertCacheResult(result) {
 	if (result?.success !== true) {
 		const detail = result?.errors?.map(({ code, message }) => `${code}: ${message}`).join("; ");
 		throw new Error(`Cloudflare CDN revalidation failed${detail ? `: ${detail}` : "."}`);
@@ -67,8 +79,26 @@ function applyCloudflareHeaders(request, response) {
 	const authoredTags = result.get("Cache-Tag");
 	if (authoredTags !== null) {
 		const url = new URL(request.url);
-		const tagHeader = validateTags(authoredTags.split(",").map((tag) => tag.trim())).map((tag) => resourceTag(url, tag)).join(",");
-		if (tagHeader.length > MAX_TAG_HEADER_BYTES) throw new RangeError("Encoded CDN tags exceed Cloudflare's 16 KB header limit.");
+		const resources = validateTags(authoredTags.split(",").map((tag) => tag.trim()));
+		const encoded = resources.map((tag) => resourceTag(url, tag));
+		const retained = [];
+		let bytes = 0;
+		for (const tag of encoded) {
+			const next = bytes + tag.length + (retained.length ? 1 : 0);
+			if (retained.length === 1e3 || next > MAX_TAG_HEADER_BYTES) break;
+			retained.push(tag);
+			bytes = next;
+		}
+		if (retained.length < resources.length) console.warn({
+			code: "KIZLO_CDN_TAGS_TRIMMED",
+			pathname: url.pathname,
+			requested: resources.length,
+			retained: retained.length,
+			dropped: resources.length - retained.length,
+			maxBytes: MAX_TAG_HEADER_BYTES,
+			maxTags: 1e3
+		});
+		const tagHeader = retained.join(",");
 		result.set("Cache-Tag", tagHeader);
 	}
 	return new Response(response.body, {
@@ -79,4 +109,4 @@ function applyCloudflareHeaders(request, response) {
 }
 
 //#endregion
-export { applyCloudflareHeaders, createCdnHeaders, revalidateTag, revalidateUrl };
+export { applyCloudflareHeaders, createCdnHeaders, getCacheContext, purgeCache, revalidateTag, revalidateTags, revalidateUrl };

package/dist/integrations/tanstack-start/cloudflare/revalidator.d.ts

@@ -0,0 +1,35 @@
+import { PostEventData, SETTINGS_INDEXED_EVENT_TYPES, SettingsEventType, TermDependencies, TermEventData } from "../../../webhook/schema.js";
+import { Integration } from "../../../shared/integration.js";
+import "../../../index.js";
+import z from "zod/v4";
+
+//#region src/integrations/tanstack-start/cloudflare/revalidator.d.ts
+type RevalidationPostData = z.output<typeof PostEventData> & {
+  affected_terms: TermDependencies;
+};
+type RevalidationTermData = z.output<typeof TermEventData> & {
+  affected_terms: TermDependencies;
+};
+interface RevalidationPostRule {
+  resourceTag(id: number): string;
+  collectionTags?(data: RevalidationPostData): readonly string[];
+}
+interface RevalidationTaxonomyRule {
+  resourceTag(id: number): string;
+  collectionTags?(id: number, data: RevalidationTermData): readonly string[];
+}
+type RevalidationSettingsEvent<K$1 extends SettingsEventType> = {
+  type: K$1;
+  data: K$1 extends (typeof SETTINGS_INDEXED_EVENT_TYPES)[number] ? {
+    key: string;
+  } : null;
+};
+interface RevalidatorOptions {
+  postTypes?: Record<string, RevalidationPostRule>;
+  taxonomies?: Record<string, RevalidationTaxonomyRule>;
+  settings?: "purge" | { [K in SettingsEventType]?: (event: RevalidationSettingsEvent<K>) => readonly string[] };
+}
+/** Optional content-change rules; does not install a response caching policy. */
+declare function revalidator(options?: RevalidatorOptions): Integration<"revalidator", Record<never, never>>;
+//#endregion
+export { RevalidationPostData, RevalidationPostRule, RevalidationSettingsEvent, RevalidationTaxonomyRule, RevalidationTermData, RevalidatorOptions, revalidator };

package/dist/integrations/tanstack-start/cloudflare/revalidator.js

@@ -0,0 +1,130 @@
+import { KizloError } from "../../../shared/error.js";
+import { createIntegration } from "../../../shared/integration.js";
+import { POST_EVENT_TYPES, PostEventData, SETTINGS_EVENT_TYPES, SETTINGS_INDEXED_EVENT_TYPES, SettingsIndexedEventData, SettingsSimpleEventData, TERM_EVENT_TYPES, TermDependencies, TermEventData } from "../../../webhook/schema.js";
+import { createEventHandler } from "../../../webhook/index.js";
+import { validateTags } from "./cache-policy.js";
+import { getCacheContext, purgeCache, revalidateTags } from "./cache.js";
+import z from "zod/v4";
+
+//#region src/integrations/tanstack-start/cloudflare/revalidator.ts
+const rule = z.object({
+	resourceTag: z.custom((value) => typeof value === "function"),
+	collectionTags: z.custom((value) => typeof value === "function").optional()
+}).strict();
+const rules = z.record(z.string().regex(/^[a-zA-Z0-9_-]+$/), rule);
+const optionsSchema = z.object({
+	postTypes: rules.optional(),
+	taxonomies: rules.optional(),
+	settings: z.union([z.literal("purge"), z.partialRecord(z.enum(SETTINGS_EVENT_TYPES), z.custom((value) => typeof value === "function"))]).optional()
+}).strict();
+/** Optional content-change rules; does not install a response caching policy. */
+function revalidator(options = {}) {
+	optionsSchema.parse(options);
+	const purgeSettings = options.settings === "purge";
+	const settings = typeof options.settings === "object" ? options.settings : {};
+	const postSchema = z.unknown().transform((data, ctx) => {
+		if (!(data !== null && typeof data === "object" && "post_type" in data && typeof data.post_type === "string" && Object.hasOwn(options.postTypes ?? {}, data.post_type))) {
+			if (Object.keys(options.postTypes ?? {}).length && (data === null || typeof data !== "object" || !("post_type" in data) || typeof data.post_type !== "string" || !data.post_type.length)) {
+				ctx.addIssue({
+					code: "custom",
+					message: "A post_type is required to select configured rules"
+				});
+				return z.NEVER;
+			}
+			return data;
+		}
+		const result = PostEventData.extend({ affected_terms: TermDependencies }).safeParse(data);
+		if (!result.success) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Complete affected_terms is required for configured post types"
+			});
+			return z.NEVER;
+		}
+		return result.data;
+	});
+	const termSchema = z.unknown().transform((data, ctx) => {
+		if (!(data !== null && typeof data === "object" && "taxonomy" in data && typeof data.taxonomy === "string" && Object.hasOwn(options.taxonomies ?? {}, data.taxonomy))) {
+			if (Object.keys(options.taxonomies ?? {}).length && (data === null || typeof data !== "object" || !("taxonomy" in data) || typeof data.taxonomy !== "string" || !data.taxonomy.length)) {
+				ctx.addIssue({
+					code: "custom",
+					message: "A taxonomy is required to select configured rules"
+				});
+				return z.NEVER;
+			}
+			return data;
+		}
+		const result = TermEventData.extend({ affected_terms: TermDependencies }).safeParse(data);
+		if (!result.success) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Complete affected_terms is required for configured taxonomies"
+			});
+			return z.NEVER;
+		}
+		return result.data;
+	});
+	return createIntegration({
+		id: "revalidator",
+		events: [{
+			...createEventHandler([
+				{
+					types: [...POST_EVENT_TYPES],
+					data: postSchema
+				},
+				{
+					types: [...TERM_EVENT_TYPES],
+					data: termSchema
+				},
+				...(purgeSettings ? SETTINGS_EVENT_TYPES : Object.keys(settings)).map((type) => ({
+					types: [type],
+					data: SETTINGS_INDEXED_EVENT_TYPES.includes(type) ? SettingsIndexedEventData : SettingsSimpleEventData
+				}))
+			], async (event, context) => {
+				if (!event) return;
+				const selected = [];
+				const addResource = (tag) => {
+					selected.push(...validateTags([tag]));
+				};
+				const addCollection = (tags) => {
+					selected.push(...validateTags(tags));
+				};
+				if (POST_EVENT_TYPES.includes(event.type)) {
+					const data = event.data;
+					const rule$1 = data && typeof data.post_type === "string" && Object.hasOwn(options.postTypes ?? {}, data.post_type) ? options.postTypes?.[data.post_type] : void 0;
+					if (!rule$1 || !data) return;
+					addResource(rule$1.resourceTag(data.post_id));
+					if (rule$1.collectionTags) addCollection(rule$1.collectionTags(data));
+				} else if (TERM_EVENT_TYPES.includes(event.type)) {
+					const data = event.data;
+					const rule$1 = data && typeof data.taxonomy === "string" && Object.hasOwn(options.taxonomies ?? {}, data.taxonomy) ? options.taxonomies?.[data.taxonomy] : void 0;
+					if (!rule$1 || !data) return;
+					for (const id of new Set([data.term_id, ...data.affected_terms[data.taxonomy] ?? []])) {
+						addResource(rule$1.resourceTag(id));
+						if (rule$1.collectionTags) addCollection(rule$1.collectionTags(id, data));
+					}
+				} else if (!purgeSettings) {
+					const setting = settings[event.type];
+					if (!setting) return;
+					addCollection(setting(event));
+				}
+				const purge = purgeSettings && SETTINGS_EVENT_TYPES.includes(event.type);
+				if (!purge && !selected.length) return;
+				const active = getCacheContext();
+				const expected = new URL(context.config.baseUrl ?? "").origin;
+				if (active.url.origin !== expected || !context.request || new URL(context.request.url).origin !== expected) throw new KizloError("UNPROCESSABLE_CONTENT", { message: "Revalidation webhook must use the configured public origin and cache-owning Worker entrypoint." });
+				try {
+					if (purge) await purgeCache();
+					else await revalidateTags(selected);
+				} catch (error) {
+					if (error !== null && typeof error === "object" && "status" in error && error.status === 429) throw new KizloError("TOO_MANY_REQUESTS", { cause: error });
+					throw error;
+				}
+			}),
+			failureMode: "retry"
+		}]
+	});
+}
+
+//#endregion
+export { revalidator };

package/dist/integrations/tanstack-start/react/integration.d.ts

@@ -3,7 +3,7 @@ import { EventHandler } from "../../../webhook/index.js";
 import { EnvSource, IntegrationRequirements } from "../../../shared/integration.js";
 import "../../../index.js";
 import { TanstackStartOptions } from "../integration.js";
-import { getStartRequestContext } from "./request-context.js";
+import { getStartRequestContext } from "../request-context.js";
 
 //#region src/integrations/tanstack-start/react/integration.d.ts
 /** Add React Start's native request context and cookies to the shared environment mapping. */

package/dist/integrations/tanstack-start/react/integration.js

@@ -1,6 +1,6 @@
 import { tanstackStart } from "../integration.js";
 import { startCookies } from "./cookies.js";
-import { getStartRequestContext } from "./request-context.js";
+import { getStartRequestContext } from "../request-context.js";
 
 //#region src/integrations/tanstack-start/react/integration.ts
 /** Add React Start's native request context and cookies to the shared environment mapping. */

package/dist/integrations/tanstack-start/react/middleware.d.ts

@@ -1,9 +1,9 @@
-import * as _tanstack_react_start0 from "@tanstack/react-start";
+import * as _tanstack_start_client_core0 from "@tanstack/start-client-core";
 import { AnyRequestMiddleware } from "@tanstack/react-start";
 
 //#region src/integrations/tanstack-start/react/middleware.d.ts
 type MiddlewareMatcher = string | readonly string[] | ((request: Request) => boolean);
 /** Wrap native request middleware with a path-to-regexp pattern or synchronous request predicate. */
-declare function matchMiddleware<Middleware extends AnyRequestMiddleware>(middleware: Middleware, matcher: MiddlewareMatcher): Pick<_tanstack_react_start0.RequestMiddlewareAfterServer<{}, readonly [Middleware], undefined>, "~types" | "options">;
+declare function matchMiddleware<Middleware extends AnyRequestMiddleware>(middleware: Middleware, matcher: MiddlewareMatcher): Pick<_tanstack_start_client_core0.RequestMiddlewareAfterServer<{}, readonly [Middleware], undefined>, "options" | "~types">;
 //#endregion
 export { MiddlewareMatcher, matchMiddleware };

package/dist/integrations/tanstack-start/{react/request-context.d.ts → request-context.d.ts}

@@ -1,4 +1,4 @@
-//#region src/integrations/tanstack-start/react/request-context.d.ts
+//#region src/integrations/tanstack-start/request-context.d.ts
 /** Read Start's native request scope; no application-owned async storage is needed. */
 declare function getStartRequestContext(): {
   request: Request;

package/dist/integrations/tanstack-start/{react/request-context.js → request-context.js}

@@ -1,7 +1,7 @@
-import { getRequest } from "@tanstack/react-start/server";
-import { getGlobalStartContext } from "@tanstack/react-start";
+import { getGlobalStartContext } from "@tanstack/start-client-core";
+import { getRequest } from "@tanstack/start-server-core/request-response";
 
-//#region src/integrations/tanstack-start/react/request-context.ts
+//#region src/integrations/tanstack-start/request-context.ts
 /** Read Start's native request scope; no application-owned async storage is needed. */
 function getStartRequestContext() {
 	let request;

package/dist/package.js

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

package/dist/post/schema.d.ts

@@ -26,13 +26,13 @@ declare const Post: z.ZodObject<{
     private: "private";
   }>;
   format: z.ZodEnum<{
+    image: "image";
     link: "link";
     status: "status";
     standard: "standard";
     aside: "aside";
     chat: "chat";
     gallery: "gallery";
-    image: "image";
     quote: "quote";
     video: "video";
     audio: "audio";
@@ -150,13 +150,13 @@ declare const PostList: z.ZodObject<{
       private: "private";
     }>;
     format: z.ZodEnum<{
+      image: "image";
       link: "link";
       status: "status";
       standard: "standard";
       aside: "aside";
       chat: "chat";
       gallery: "gallery";
-      image: "image";
       quote: "quote";
       video: "video";
       audio: "audio";

package/dist/procedures.d.ts

@@ -44,7 +44,7 @@ declare const CORE_PROCEDURES: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
+        orderby?: "id" | "slug" | "parent" | "title" | "author" | "date" | "include" | "include_slugs" | "modified" | "relevance" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         taxRelation?: "AND" | "OR" | undefined;
@@ -99,7 +99,7 @@ declare const CORE_PROCEDURES: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
+        orderby?: "id" | "slug" | "parent" | "title" | "author" | "date" | "include" | "include_slugs" | "modified" | "relevance" | "menu_order" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         parent?: string | number | (string | number)[] | undefined;
@@ -136,7 +136,7 @@ declare const CORE_PROCEDURES: {
         exclude?: string | number | (string | number)[] | undefined;
         include?: string | number | (string | number)[] | undefined;
         order?: "asc" | "desc" | undefined;
-        orderBy?: "description" | "count" | "id" | "slug" | "name" | "include" | "include_slugs" | "term_group" | undefined;
+        orderBy?: "id" | "name" | "slug" | "description" | "include" | "include_slugs" | "term_group" | "count" | undefined;
         hideEmpty?: string | boolean | undefined;
         parent?: string | number | undefined;
         post?: string | number | undefined;
@@ -172,7 +172,7 @@ declare const CORE_PROCEDURES: {
         exclude?: string | number | (string | number)[] | undefined;
         include?: string | number | (string | number)[] | undefined;
         order?: "asc" | "desc" | undefined;
-        orderBy?: "description" | "count" | "id" | "slug" | "name" | "include" | "include_slugs" | "term_group" | undefined;
+        orderBy?: "id" | "name" | "slug" | "description" | "include" | "include_slugs" | "term_group" | "count" | undefined;
         hideEmpty?: string | boolean | undefined;
         post?: string | number | undefined;
         slug?: string | string[] | undefined;
@@ -241,7 +241,7 @@ declare const CORE_PROCEDURES: {
     sitemaps: {
       list: Procedure<"internal", {}, {
         key: string;
-        type: "post_type" | "taxonomy" | "author";
+        type: "author" | "post_type" | "taxonomy";
         pages: number;
         lastmod: string;
       }[], DefinedErrorMapLike>;
@@ -249,7 +249,7 @@ declare const CORE_PROCEDURES: {
         origin: string;
         sitemaps: {
           key: string;
-          type: "post_type" | "taxonomy" | "author";
+          type: "author" | "post_type" | "taxonomy";
           pages: number;
           lastmod: string;
         }[];
@@ -292,7 +292,7 @@ declare const CORE_PROCEDURES: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "id" | "slug" | "parent" | "title" | "author" | "date" | "include" | "include_slugs" | "relevance" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -371,7 +371,7 @@ declare const CORE_PROCEDURES: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "id" | "slug" | "parent" | "title" | "author" | "date" | "include" | "include_slugs" | "relevance" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -507,7 +507,7 @@ declare const CORE_PROCEDURES: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "parent" | "include" | "post" | undefined;
+        orderby?: "id" | "parent" | "date" | "include" | "post" | undefined;
         parent?: string | number | (string | number)[] | undefined;
         parentExclude?: string | number | (string | number)[] | undefined;
         post?: string | number | (string | number)[] | undefined;
@@ -635,8 +635,8 @@ declare const CORE_PROCEDURES: {
     get: Procedure<"internal", {}, _kizlo_shared11.Settings, DefinedErrorMapLike>;
     site: {
       update: Procedure<"internal", {
-        url?: string | null | undefined;
         name?: string | null | undefined;
+        url?: string | null | undefined;
         backend_url?: string | null | undefined;
         secret?: string | null | undefined;
         alternate_name?: string | null | undefined;

package/dist/seo/schema.d.ts

@@ -108,17 +108,17 @@ declare const Seo: z.ZodObject<{
 type Seo = z.infer<typeof Seo>;
 declare const CONTENT_TYPES: readonly ["post_type", "taxonomy", "author"];
 declare const ContentType: z.ZodEnum<{
+  author: "author";
   post_type: "post_type";
   taxonomy: "taxonomy";
-  author: "author";
 }>;
 type ContentType = z.infer<typeof ContentType>;
 declare const Sitemap: z.ZodObject<{
   key: z.ZodString;
   type: z.ZodEnum<{
+    author: "author";
     post_type: "post_type";
     taxonomy: "taxonomy";
-    author: "author";
   }>;
   pages: z.ZodNumber;
   lastmod: z.ZodString;
@@ -127,9 +127,9 @@ type Sitemap = z.infer<typeof Sitemap>;
 declare const SitemapList: z.ZodArray<z.ZodObject<{
   key: z.ZodString;
   type: z.ZodEnum<{
+    author: "author";
     post_type: "post_type";
     taxonomy: "taxonomy";
-    author: "author";
   }>;
   pages: z.ZodNumber;
   lastmod: z.ZodString;
@@ -140,9 +140,9 @@ declare const SitemapIndex: z.ZodObject<{
   sitemaps: z.ZodArray<z.ZodObject<{
     key: z.ZodString;
     type: z.ZodEnum<{
+      author: "author";
       post_type: "post_type";
       taxonomy: "taxonomy";
-      author: "author";
     }>;
     pages: z.ZodNumber;
     lastmod: z.ZodString;
@@ -174,9 +174,9 @@ declare const SitemapUrlList: z.ZodArray<z.ZodObject<{
 type SitemapUrlList = z.infer<typeof SitemapUrlList>;
 declare const ListSitemapUrlInputBase: z.ZodObject<{
   type: z.ZodEnum<{
+    author: "author";
     post_type: "post_type";
     taxonomy: "taxonomy";
-    author: "author";
   }>;
   page: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodCoercedNumber<string | number>>>;
 }, z.core.$strip>;

package/dist/tanstack-start/{react/cloudflare.d.ts → cloudflare.d.ts}

@@ -1,9 +1,10 @@
-import { GeoAdapter } from "../../adapters/geo.js";
-import { Integration } from "../../shared/integration.js";
-import "../../index.js";
-import { CdnHeadersOptions, CloudflareCacheBinding, CloudflareCacheResult, createCdnHeaders, revalidateTag, revalidateUrl } from "../../integrations/tanstack-start/react/cloudflare/cache.js";
+import { GeoAdapter } from "../adapters/geo.js";
+import { Integration } from "../shared/integration.js";
+import "../index.js";
+import { CdnHeadersOptions, CloudflareCacheBinding, CloudflareCacheResult, createCdnHeaders, purgeCache, revalidateTag, revalidateUrl } from "../integrations/tanstack-start/cloudflare/cache.js";
+import { RevalidationPostData, RevalidationPostRule, RevalidationSettingsEvent, RevalidationTaxonomyRule, RevalidationTermData, RevalidatorOptions, revalidator } from "../integrations/tanstack-start/cloudflare/revalidator.js";
 
-//#region src/integrations/tanstack-start/react/cloudflare.d.ts
+//#region src/integrations/tanstack-start/cloudflare.d.ts
 interface ExecutionContext {
   cache?: CloudflareCacheBinding;
   waitUntil(promise: Promise<unknown>): void;
@@ -24,4 +25,4 @@ declare function withCloudflare<Env, Context extends ExecutionContext = Executio
   fetch(request: Request, env: Env, executionCtx: Context): Promise<Response>;
 };
 //#endregion
-export { type CdnHeadersOptions, type CloudflareCacheBinding, type CloudflareCacheResult, cloudflare, createCdnHeaders, geoCloudflare, revalidateTag, revalidateUrl, withCloudflare };
+export { type CdnHeadersOptions, type CloudflareCacheBinding, type CloudflareCacheResult, type RevalidationPostData, type RevalidationPostRule, type RevalidationSettingsEvent, type RevalidationTaxonomyRule, type RevalidationTermData, type RevalidatorOptions, cloudflare, createCdnHeaders, geoCloudflare, purgeCache, revalidateTag, revalidateUrl, revalidator, withCloudflare };

package/dist/tanstack-start/{react/cloudflare.js → cloudflare.js}

@@ -1,10 +1,11 @@
-import { cloudflareConnInfo } from "../../adapters/cloudflare-connection.js";
-import { FRAMEWORK_INTEGRATION_ORDER } from "../../shared/constants.js";
-import { createIntegration } from "../../shared/integration.js";
-import { getStartRequestContext } from "../../integrations/tanstack-start/react/request-context.js";
-import { applyCloudflareHeaders, createCdnHeaders, revalidateTag, revalidateUrl } from "../../integrations/tanstack-start/react/cloudflare/cache.js";
+import { cloudflareConnInfo } from "../adapters/cloudflare-connection.js";
+import { FRAMEWORK_INTEGRATION_ORDER } from "../shared/constants.js";
+import { createIntegration } from "../shared/integration.js";
+import { getStartRequestContext } from "../integrations/tanstack-start/request-context.js";
+import { applyCloudflareHeaders, createCdnHeaders, purgeCache, revalidateTag, revalidateUrl } from "../integrations/tanstack-start/cloudflare/cache.js";
+import { revalidator } from "../integrations/tanstack-start/cloudflare/revalidator.js";
 
-//#region src/integrations/tanstack-start/react/cloudflare.ts
+//#region src/integrations/tanstack-start/cloudflare.ts
 /** Cloudflare connection metadata, using TanStack Start's existing request scope. */
 function geoCloudflare() {
 	return { getConnInfo(request) {
@@ -30,4 +31,4 @@ function withCloudflare(handler) {
 }
 
 //#endregion
-export { cloudflare, createCdnHeaders, geoCloudflare, revalidateTag, revalidateUrl, withCloudflare };
+export { cloudflare, createCdnHeaders, geoCloudflare, purgeCache, revalidateTag, revalidateUrl, revalidator, withCloudflare };

package/dist/webhook/index.d.ts

@@ -22,6 +22,8 @@ interface WebhookOptions {
   events?: EventHandler[];
 }
 interface EventHandler {
+  /** Required handlers fail acknowledgement so the sender can retry. Defaults to log-only. */
+  failureMode?: "log" | "retry";
   events?: AnyEvents;
   handler: EventHandlerFn<AnyEvents>;
 }

package/dist/webhook/index.js

@@ -31,12 +31,19 @@ function createWebhookRouter(options) {
 			headers
 		}));
 		if (err) throw new KizloError("FORBIDDEN", { message: "Signature verification failed." });
-		const results = await Promise.allSettled((options?.events ?? []).map(async ({ events, handler }) => {
-			const event = await validateEvent(events, input.body);
+		const results = await Promise.allSettled((options?.events ?? []).map(async ({ events, handler, failureMode }) => {
+			const event = await validateEvent(events, input.body, failureMode);
 			if (!event) return;
 			await handler(event, context);
 		}));
 		for (const result of results) if (result.status === "rejected") context.logger.error("Webhook handler failed", result.reason);
+		const required = results.find((result, index) => result.status === "rejected" && options?.events?.[index]?.failureMode === "retry");
+		if (required?.status === "rejected") {
+			if (required.reason instanceof KizloError && required.reason.status === 422) throw required.reason;
+			const limited = required.reason instanceof KizloError && required.reason.status === 429;
+			if (limited) context.headers?.set("Retry-After", "60");
+			throw new KizloError(limited ? "TOO_MANY_REQUESTS" : "SERVICE_UNAVAILABLE", { message: "Required webhook work failed. Retry delivery." });
+		}
 	}) };
 }
 

package/dist/webhook/schema.d.ts

@@ -2,6 +2,38 @@ import z from "zod/v4";
 
 //#region src/webhook/schema.d.ts
 
+declare const SETTINGS_INDEXED_EVENT_TYPES: readonly ["settings.post_type.updated", "settings.taxonomy.updated"];
+declare const SettingsEventType: z.ZodEnum<{
+  "settings.site.updated": "settings.site.updated";
+  "settings.brand.updated": "settings.brand.updated";
+  "settings.identity.updated": "settings.identity.updated";
+  "settings.authors.updated": "settings.authors.updated";
+  "settings.crawling.updated": "settings.crawling.updated";
+  "settings.headless.updated": "settings.headless.updated";
+  "settings.integration.updated": "settings.integration.updated";
+  "settings.woocommerce.updated": "settings.woocommerce.updated";
+  "settings.post_type.updated": "settings.post_type.updated";
+  "settings.taxonomy.updated": "settings.taxonomy.updated";
+}>;
+type SettingsEventType = z.infer<typeof SettingsEventType>;
+declare const TermDependencies: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodArray<z.ZodNumber>, z.ZodTransform<number[], number[]>>>;
+type TermDependencies = z.infer<typeof TermDependencies>;
+declare const PostEventData: z.ZodObject<{
+  post_id: z.ZodNumber;
+  affected_terms: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodArray<z.ZodNumber>, z.ZodTransform<number[], number[]>>>>>;
+  post_type: z.ZodString;
+  url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PostEventData = z.infer<typeof PostEventData>;
+declare const TermEventData: z.ZodObject<{
+  term_id: z.ZodNumber;
+  affected_terms: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodArray<z.ZodNumber>, z.ZodTransform<number[], number[]>>>>>;
+  taxonomy: z.ZodString;
+  post_types: z.ZodArray<z.ZodString>;
+  count: z.ZodNumber;
+  url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TermEventData = z.infer<typeof TermEventData>;
 declare const KizloEvent: z.ZodUnion<readonly [z.ZodObject<{
   type: z.ZodEnum<{
     "post.created": "post.created";
@@ -11,6 +43,7 @@ declare const KizloEvent: z.ZodUnion<readonly [z.ZodObject<{
   }>;
   data: z.ZodObject<{
     post_id: z.ZodNumber;
+    affected_terms: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodArray<z.ZodNumber>, z.ZodTransform<number[], number[]>>>>>;
     post_type: z.ZodString;
     url: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>;
@@ -22,6 +55,7 @@ declare const KizloEvent: z.ZodUnion<readonly [z.ZodObject<{
   }>;
   data: z.ZodObject<{
     term_id: z.ZodNumber;
+    affected_terms: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodArray<z.ZodNumber>, z.ZodTransform<number[], number[]>>>>>;
     taxonomy: z.ZodString;
     post_types: z.ZodArray<z.ZodString>;
     count: z.ZodNumber;
@@ -34,6 +68,7 @@ declare const KizloEvent: z.ZodUnion<readonly [z.ZodObject<{
     "settings.identity.updated": "settings.identity.updated";
     "settings.authors.updated": "settings.authors.updated";
     "settings.crawling.updated": "settings.crawling.updated";
+    "settings.headless.updated": "settings.headless.updated";
     "settings.integration.updated": "settings.integration.updated";
     "settings.woocommerce.updated": "settings.woocommerce.updated";
   }>;
@@ -49,4 +84,4 @@ declare const KizloEvent: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>]>;
 type KizloEvent = z.infer<typeof KizloEvent>;
 //#endregion
-export { KizloEvent };
+export { KizloEvent, PostEventData, SETTINGS_INDEXED_EVENT_TYPES, SettingsEventType, TermDependencies, TermEventData };

package/dist/webhook/schema.js

@@ -20,6 +20,7 @@ const SETTINGS_SIMPLE_EVENT_TYPES = [
 	"settings.identity.updated",
 	"settings.authors.updated",
 	"settings.crawling.updated",
+	"settings.headless.updated",
 	"settings.integration.updated",
 	"settings.woocommerce.updated"
 ];
@@ -34,8 +35,10 @@ const EVENT_TYPES = [
 	...SETTINGS_EVENT_TYPES
 ];
 const EventType = z.enum(EVENT_TYPES);
+const TermDependencies = z.record(z.string().min(1), z.array(z.number().int().positive().max(Number.MAX_SAFE_INTEGER)).transform((ids) => [...new Set(ids)]));
 const PostEventData = z.object({
-	post_id: z.number(),
+	post_id: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+	affected_terms: TermDependencies.nullable().optional(),
 	post_type: z.string(),
 	url: z.string().optional()
 });
@@ -44,7 +47,8 @@ const PostEvent = z.object({
 	data: PostEventData
 });
 const TermEventData = z.object({
-	term_id: z.number(),
+	term_id: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+	affected_terms: TermDependencies.nullable().optional(),
 	taxonomy: z.string(),
 	post_types: z.array(z.string()),
 	count: z.number().nonnegative(),
@@ -77,4 +81,4 @@ const AnyEvent = z.object({
 });
 
 //#endregion
-export { AnyEvent, KizloEvent, POST_EVENT_TYPES, SETTINGS_EVENT_TYPES, TERM_EVENT_TYPES };
+export { AnyEvent, KizloEvent, POST_EVENT_TYPES, PostEventData, SETTINGS_EVENT_TYPES, SETTINGS_INDEXED_EVENT_TYPES, SettingsIndexedEventData, SettingsSimpleEventData, TERM_EVENT_TYPES, TermDependencies, TermEventData };

package/dist/webhook/utils.js

@@ -1,8 +1,18 @@
+import { KizloError } from "../shared/error.js";
 import { KizloEvent } from "./schema.js";
 import { safeValidateSchema } from "@kizlo/shared";
 
 //#region src/webhook/utils.ts
-async function validateEvent(events, data) {
+async function validateEvent(events, data, failureMode = "log") {
+	const explicit = events?.find((entry) => entry.types.includes(data.type))?.data;
+	if (failureMode === "retry" && explicit) {
+		const result = await safeValidateSchema(explicit, data.data);
+		if (!result.success) throw new KizloError("UNPROCESSABLE_CONTENT", { message: "Invalid webhook dependencies. Update the event-producing plugin and check affected_terms." });
+		return {
+			type: data.type,
+			data: result.value
+		};
+	}
 	const internal = await safeValidateSchema(KizloEvent, data);
 	if (internal.success) return internal.value;
 	const external = events?.find((a) => a.types.includes(data.type))?.data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizlo",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "type": "module",
   "description": "A headless WordPress framework for TypeScript.",
   "keywords": [
@@ -106,10 +106,10 @@
         "default": "./dist/tanstack-start/react/server.js"
       }
     },
-    "./tanstack-start/react/cloudflare": {
+    "./tanstack-start/cloudflare": {
       "import": {
-        "types": "./dist/tanstack-start/react/cloudflare.d.ts",
-        "default": "./dist/tanstack-start/react/cloudflare.js"
+        "types": "./dist/tanstack-start/cloudflare.d.ts",
+        "default": "./dist/tanstack-start/cloudflare.js"
       }
     }
   },
@@ -147,6 +147,8 @@
   "peerDependencies": {
     "@tanstack/react-router": "^1.170.41",
     "@tanstack/react-start": "^1.168.60",
+    "@tanstack/start-client-core": "^1.170.34",
+    "@tanstack/start-server-core": "^1.169.39",
     "astro": "^7.0.0",
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0",
@@ -160,6 +162,12 @@
     "@tanstack/react-start": {
       "optional": true
     },
+    "@tanstack/start-client-core": {
+      "optional": true
+    },
+    "@tanstack/start-server-core": {
+      "optional": true
+    },
     "astro": {
       "optional": true
     },