kizlo 0.29.0 → 0.31.0

package/dist/adapters/geo.cloudflare.d.ts

@@ -1,7 +1,7 @@
 import { GeoAdapter } from "./geo.js";
 
 //#region src/adapters/geo.cloudflare.d.ts
-/** Read trusted Cloudflare connection headers in Next.js/vinext. Only use behind Cloudflare ingress. */
+/** Read trusted Cloudflare connection headers in Next.js. Only use behind Cloudflare ingress. */
 declare function geoCloudflareNext(): GeoAdapter;
 //#endregion
 export { geoCloudflareNext };

package/dist/adapters/geo.cloudflare.js

@@ -1,7 +1,7 @@
 import { cloudflareConnInfo } from "./cloudflare-connection.js";
 
 //#region src/adapters/geo.cloudflare.ts
-/** Read trusted Cloudflare connection headers in Next.js/vinext. Only use behind Cloudflare ingress. */
+/** Read trusted Cloudflare connection headers in Next.js. Only use behind Cloudflare ingress. */
 function geoCloudflareNext() {
 	return { getConnInfo: async (request) => {
 		let headers = request?.headers;

package/dist/adapters/request-context.d.ts

@@ -0,0 +1,12 @@
+//#region src/adapters/request-context.d.ts
+/** Request-local values supplied by a runtime integration, never by global core state. */
+interface RequestContextAdapter {
+  get(): {
+    request: Request;
+    values: object;
+  } | undefined;
+  /** Optional when the framework already owns request scoping. */
+  run?(request: Request, values: object | undefined, handle: () => Promise<Response>): Promise<Response>;
+}
+//#endregion
+export { RequestContextAdapter };

package/dist/adapters/types.d.ts

@@ -3,6 +3,7 @@ import { CaptchaAdapter } from "./captcha.js";
 import { CookiesAdapter } from "../shared/types.js";
 import { GeoAdapter } from "./geo.js";
 import { LoggerAdapter } from "./logger.js";
+import { RequestContextAdapter } from "./request-context.js";
 
 //#region src/adapters/types.d.ts
 /** The service contracts Kizlo integrations can provide at runtime. */
@@ -12,6 +13,7 @@ interface ServiceAdapters {
   geo?: GeoAdapter;
   logger?: LoggerAdapter;
   cookies?: CookiesAdapter;
+  requestContext?: RequestContextAdapter;
 }
 /** Merge adapter contributions in order without letting `undefined` erase an earlier value. */
 declare function mergeServiceAdapters(...contributions: (ServiceAdapters | undefined)[]): ServiceAdapters;

package/dist/adapters/types.js

@@ -9,6 +9,7 @@ function mergeServiceAdapters(...contributions) {
 		if (contribution.geo !== void 0) adapters.geo = contribution.geo;
 		if (contribution.logger !== void 0) adapters.logger = contribution.logger;
 		if (contribution.cookies !== void 0) adapters.cookies = contribution.cookies;
+		if (contribution.requestContext !== void 0) adapters.requestContext = contribution.requestContext;
 	}
 	return adapters;
 }

package/dist/context.d.ts

@@ -1,5 +1,4 @@
 import { ActiveWordPressClient, WordPressCredentials } from "./wordpress/types.js";
-import { WordPressTransport } from "./wordpress/transport.js";
 import "./wordpress/index.js";
 import { AuthUser } from "./adapters/auth.js";
 import { PreviewTokenPayload } from "./shared/schema.js";
@@ -31,8 +30,8 @@ type VerifyPreviewTokenFn = (token: string) => Promise<PreviewTokenPayload | nul
  * the server builds. A procedure's handler receives this base plus whatever its middleware injected
  * via `next({ context })`.
  */
-interface ProcedureContext {
-  /** The incoming HTTP `Request`, or `null` for server-side (non-HTTP) invocations. */
+interface BuiltinProcedureContext {
+  /** The active HTTP `Request`, or `null` outside a request scope. */
   request: Request | null;
   /** Response headers to be sent (e.g. `Set-Cookie`), or `null` server-side. */
   headers: Headers | null;
@@ -59,6 +58,10 @@ interface ProcedureContext {
   /** How the procedure was called: `"client"` (over HTTP) or `"server"` (direct server invocation). */
   invokedBy: "client" | "server";
 }
+/** Augment in the application to add typed, server-supplied request fields. */
+interface ProcedureContext extends BuiltinProcedureContext {}
+/** The application fields accepted by handler(request, values), excluding Kizlo-owned fields. */
+type PlatformRequestCtx = Omit<ProcedureContext, keyof BuiltinProcedureContext> & object;
 declare class Context {
   private readonly config;
   private readonly logger;
@@ -77,35 +80,15 @@ declare class Context {
   private warnIfOutdated;
   /** Bold yellow, boxed in dashes so it stands out in a busy dev console. */
   private warn;
-  createRestContext(request: Request): {
-    getConnInfo: ConnInfoFn;
-    verifyCaptcha: VerifyCaptchaFn;
-    getSession: SessionFn;
-    verifyPreviewToken: VerifyPreviewTokenFn;
-    cookies: CookiesStorage;
-    invokedBy: "client";
-    wordpress: WordPressTransport;
-    settings: SettingsService;
-    email: EmailService;
-    headers: Headers;
+  withRequestContext(request: Request, values: PlatformRequestCtx | undefined, handle: () => Promise<Response>): Promise<Response>;
+  createRestContext(request: Request, values?: PlatformRequestCtx): ProcedureContext & {
     request: Request;
-    config: ContextConfig;
-    logger: Logger;
+    headers: Headers;
+    invokedBy: "client";
   };
-  createServerContext(): {
-    getSession: SessionFn;
-    getConnInfo: ConnInfoFn;
-    verifyCaptcha: VerifyCaptchaFn;
-    verifyPreviewToken: VerifyPreviewTokenFn;
-    invokedBy: "server";
-    wordpress: WordPressTransport;
-    settings: SettingsService;
-    email: EmailService;
-    cookies: CookiesStorage;
+  createServerContext(): ProcedureContext & {
     headers: null;
-    request: null;
-    config: ContextConfig;
-    logger: Logger;
+    invokedBy: "server";
   };
   private createRestCookieStorage;
   private createVerifyCaptchaFn;
@@ -115,4 +98,4 @@ declare class Context {
   private createLogger;
 }
 //#endregion
-export { ConnInfoFn, Context, ContextConfig, ProcedureContext, SessionFn, VerifyCaptchaFn, VerifyPreviewTokenFn };
+export { ConnInfoFn, Context, ContextConfig, PlatformRequestCtx, ProcedureContext, SessionFn, VerifyCaptchaFn, VerifyPreviewTokenFn };

package/dist/context.js

@@ -102,9 +102,15 @@ var Context = class {
 		const border = "-".repeat(inner.length + 2);
 		console.warn(`\n\x1b[1m\x1b[33m${border}\n|${inner}|\n${border}\x1b[0m\n`);
 	}
-	createRestContext(request) {
+	withRequestContext(request, values, handle) {
+		if (values !== void 0 && (values === null || typeof values !== "object" || Array.isArray(values))) throw new TypeError("Request context must be an object.");
+		return this.config.adapters?.requestContext?.run?.(request, values, handle) ?? handle();
+	}
+	createRestContext(request, values) {
 		const headers = new Headers();
 		return {
+			...this.config.adapters?.requestContext?.get()?.values,
+			...values,
 			headers,
 			request: request.clone(),
 			config: this.config,
@@ -123,21 +129,24 @@ var Context = class {
 		};
 	}
 	createServerContext() {
+		const scope = this.config.adapters?.requestContext?.get();
+		const request = scope?.request ?? null;
 		const cookies = new CookiesStorage(this.config.adapters?.cookies);
 		return {
+			...scope?.values,
 			cookies,
 			headers: null,
-			request: null,
+			request,
 			config: this.config,
 			logger: this.logger,
-			...this.config.adapters?.geo ? this.createServices(null) : {
+			...this.config.adapters?.geo ? this.createServices(request) : {
 				wordpress: this.wordpress,
 				settings: this.settings,
 				email: this.email
 			},
-			getSession: this.createGetSessionFn(null, cookies),
-			getConnInfo: this.createConnInfoFn(null),
-			verifyCaptcha: this.createVerifyCaptchaFn(null),
+			getSession: this.createGetSessionFn(request, cookies),
+			getConnInfo: this.createConnInfoFn(request),
+			verifyCaptcha: this.createVerifyCaptchaFn(request),
 			verifyPreviewToken: this.createVerifyPreviewTokenFn(),
 			invokedBy: "server"
 		};

package/dist/index.d.ts

@@ -17,14 +17,14 @@ import { ConsoleLogAdapterOptions, LogLevel, LogPayload, Logger, LoggerAdapter,
 import { ServiceAdapters, mergeServiceAdapters } from "./adapters/types.js";
 import { AuthorsSettings, AuthorsSettingsInput, BrandSettings, BrandSettingsInput, CrawlingSettings, CrawlingSettingsInput, HeadlessSettings, HeadlessSettingsInput, IdentitySettings, IdentitySettingsInput, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, PersonSettings, PersonSettingsInput, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, Settings, SiteSettings, SiteSettingsInput, SocialProfile, TaxonomySettings, TaxonomySettingsInput, UploadsSettings, UploadsSettingsInput, WebhookSettings, WebhookSettingsInput } from "./settings/service.interface.js";
 import { IconDescriptor, ManifestIcon, ResolvedIcons, resolveIcons } from "./brand/icons.js";
+import { CookiesStorage } from "./cookie.js";
+import { SettingsService } from "./settings/service.js";
+import { ConnInfoFn, Context, ContextConfig, PlatformRequestCtx, ProcedureContext, SessionFn, VerifyCaptchaFn, VerifyPreviewTokenFn } from "./context.js";
 import { Post, PostCustomFields, PostCustomFieldsSchema } from "./post/schema.js";
 import { Page, PageCustomFields, PageCustomFieldsSchema } from "./page/schema.js";
 import { Category, CategoryCustomFields, CategoryCustomFieldsSchema } from "./category/schema.js";
 import { Tag, TagCustomFields, TagCustomFieldsSchema } from "./tag/schema.js";
 import { CORE_PROCEDURES, CoreProcedures } from "./procedures.js";
-import { CookiesStorage } from "./cookie.js";
-import { SettingsService } from "./settings/service.js";
-import { ConnInfoFn, Context, ContextConfig, ProcedureContext, SessionFn, VerifyCaptchaFn, VerifyPreviewTokenFn } from "./context.js";
 import { AnyEventSchema, AnyEvents, EventHandler, EventHandlerFn, InferEventUnion, WebhookOptions, createEventHandler, createWebhookRouter } from "./webhook/index.js";
 import { COMMON_ERRORS, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, DefinedErrorMapLike, ErrorDefinition, KizloError, KizloErrorOptions, ThrowableErrorFn, ThrowableErrorMap, WithCommonErrorMap, createThrowableErrorMap, defineErrorMap, isKizloError, toKizloError } from "./shared/error.js";
 import { AnyMiddleware, ExtractMiddlewareContextOutput, InferMiddlewares, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, createMiddleware } from "./shared/middleware.js";
@@ -44,4 +44,4 @@ 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 { ActiveKizloClient, ActiveWordPressClient, AnyContext, AnyEventSchema, AnyEvents, AnyIntegration, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureTree, AuthAdapter, AuthGetSession, AuthUser, AuthorsSettings, AuthorsSettingsInput, BaseHandlerOptions, BrandSettings, BrandSettingsInput, COMMON_ERRORS, CONTENT_TYPES, CORE_PROCEDURES, CaptchaAdapter, type Category, type CategoryCustomFields, CategoryCustomFieldsSchema, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CookiesStorage, CoreProcedures, CrawlingSettings, CrawlingSettingsInput, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, EnvReader, EnvRecord, EnvSource, ErrorDefinition, EventHandler, EventHandlerFn, ExtractIntegrationProcedures, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, HeadlessSettings, HeadlessSettingsInput, IconDescriptor, Identifier, IdentifierInput, IdentitySettings, IdentitySettingsInput, InferClientData, InferClientError, InferClientInput, InferClientResult, InferEventUnion, InferIntegrationProcedures, InferMiddlewares, InferProcedureData, InferProcedureError, InferProcedureInput, InferProcedureResult, Integration, IntegrationRequirements, InvocationScope, JsonValue, Kizlo, KizloBrowserClient, KizloClient, KizloClientConfig, KizloConfig, KizloEnv, KizloError, KizloErrorOptions, KizloErrorUnion, KizloProcedureRegistry, KizloResult, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, ManifestIcon, MaybeCallerOptions, MaybeOptionalOptions, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, type Page, type PageCustomFields, PageCustomFieldsSchema, PersonSettings, PersonSettingsInput, PluginSource, type Post, type PostCustomFields, PostCustomFieldsSchema, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureMethod, ProcedureOptions, ProcedureTreeDepthTuple, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedIcons, ResolvedSchemaInput, ResolvedSchemaOutput, ResultClient, Robots, RobotsRule, RootProcedures, S2SClient, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServiceAdapters, SessionFn, Settings, SettingsService, SettleContext, ShaAlgorithm, SiteSettings, SiteSettingsInput, Sitemap, SitemapIndex, SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, SocialProfile, type Tag, type TagCustomFields, TagCustomFieldsSchema, TaxonomySettings, TaxonomySettingsInput, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UploadsSettings, UploadsSettingsInput, VerifyCaptchaFn, VerifyPreviewTokenFn, WEB_MANIFEST_ROUTE, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_CustomFields, WP_CustomFieldsPath, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointError, WP_EndpointInput, WP_EndpointPath, WP_EndpointResult, WP_Error, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_RequestParts, WP_ResponseContentType, WP_Result, WP_Schema, WP_Success, WP_TransportFailure, WP_TypedHeaders, WebManifest, WebhookOptions, WebhookSettings, WebhookSettingsInput, WithCommonErrorMap, WordPressClientRegistry, WordPressCredentials, WordPressCustomFieldsRegistry, WordPressEndpointRegistry, WordPressEnv, WordPressSchemaRegistry, WordPressTransport, WordPressTransportOptions, WordPressTransportResult, altcha, arkose, assertIntegrationEndpoints, assertIntegrationEnv, authMock, buildProcedure, buildWebManifest, buildWordPressRequest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createGeoAdapter, createIntegration, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createResultClient, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, customFieldsSchema, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoCloudflareNext, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, integrationEnv, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, mergeServiceAdapters, missingEndpoints, missingEnv, noopAdapter, parseIdentifier, parseSitemapSlug, readEnv, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, resolveWordPressConnection, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, sortIntegrations, toKizloError, turnstile, wordPressConnectionComplete, wpEndpoint, xmlResponse };
+export { ActiveKizloClient, ActiveWordPressClient, AnyContext, AnyEventSchema, AnyEvents, AnyIntegration, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureTree, AuthAdapter, AuthGetSession, AuthUser, AuthorsSettings, AuthorsSettingsInput, BaseHandlerOptions, BrandSettings, BrandSettingsInput, COMMON_ERRORS, CONTENT_TYPES, CORE_PROCEDURES, CaptchaAdapter, type Category, type CategoryCustomFields, CategoryCustomFieldsSchema, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CookiesStorage, CoreProcedures, CrawlingSettings, CrawlingSettingsInput, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, EnvReader, EnvRecord, EnvSource, ErrorDefinition, EventHandler, EventHandlerFn, ExtractIntegrationProcedures, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, HeadlessSettings, HeadlessSettingsInput, IconDescriptor, Identifier, IdentifierInput, IdentitySettings, IdentitySettingsInput, InferClientData, InferClientError, InferClientInput, InferClientResult, InferEventUnion, InferIntegrationProcedures, InferMiddlewares, InferProcedureData, InferProcedureError, InferProcedureInput, InferProcedureResult, Integration, IntegrationRequirements, InvocationScope, JsonValue, Kizlo, KizloBrowserClient, KizloClient, KizloClientConfig, KizloConfig, KizloEnv, KizloError, KizloErrorOptions, KizloErrorUnion, KizloProcedureRegistry, KizloResult, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, ManifestIcon, MaybeCallerOptions, MaybeOptionalOptions, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, type Page, type PageCustomFields, PageCustomFieldsSchema, PersonSettings, PersonSettingsInput, PlatformRequestCtx, PluginSource, type Post, type PostCustomFields, PostCustomFieldsSchema, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureMethod, ProcedureOptions, ProcedureTreeDepthTuple, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedIcons, ResolvedSchemaInput, ResolvedSchemaOutput, ResultClient, Robots, RobotsRule, RootProcedures, S2SClient, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServiceAdapters, SessionFn, Settings, SettingsService, SettleContext, ShaAlgorithm, SiteSettings, SiteSettingsInput, Sitemap, SitemapIndex, SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, SocialProfile, type Tag, type TagCustomFields, TagCustomFieldsSchema, TaxonomySettings, TaxonomySettingsInput, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UploadsSettings, UploadsSettingsInput, VerifyCaptchaFn, VerifyPreviewTokenFn, WEB_MANIFEST_ROUTE, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_CustomFields, WP_CustomFieldsPath, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointError, WP_EndpointInput, WP_EndpointPath, WP_EndpointResult, WP_Error, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_RequestParts, WP_ResponseContentType, WP_Result, WP_Schema, WP_Success, WP_TransportFailure, WP_TypedHeaders, WebManifest, WebhookOptions, WebhookSettings, WebhookSettingsInput, WithCommonErrorMap, WordPressClientRegistry, WordPressCredentials, WordPressCustomFieldsRegistry, WordPressEndpointRegistry, WordPressEnv, WordPressSchemaRegistry, WordPressTransport, WordPressTransportOptions, WordPressTransportResult, altcha, arkose, assertIntegrationEndpoints, assertIntegrationEnv, authMock, buildProcedure, buildWebManifest, buildWordPressRequest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createGeoAdapter, createIntegration, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createResultClient, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, customFieldsSchema, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoCloudflareNext, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, integrationEnv, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, mergeServiceAdapters, missingEndpoints, missingEnv, noopAdapter, parseIdentifier, parseSitemapSlug, readEnv, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, resolveWordPressConnection, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, sortIntegrations, toKizloError, turnstile, wordPressConnectionComplete, wpEndpoint, xmlResponse };

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

@@ -0,0 +1,13 @@
+//#region src/integrations/nextjs/api.d.ts
+/** Map framework route methods to Kizlo without passing Next.js params as platform context. */
+declare function toNextJsHandler(handler: (request: Request) => Response | Promise<Response>): {
+  GET: (request: Request) => Response | Promise<Response>;
+  POST: (request: Request) => Response | Promise<Response>;
+  PUT: (request: Request) => Response | Promise<Response>;
+  PATCH: (request: Request) => Response | Promise<Response>;
+  DELETE: (request: Request) => Response | Promise<Response>;
+  OPTIONS: (request: Request) => Response | Promise<Response>;
+  HEAD: (request: Request) => Response | Promise<Response>;
+};
+//#endregion
+export { toNextJsHandler };

package/dist/integrations/nextjs/api.js

@@ -0,0 +1,17 @@
+//#region src/integrations/nextjs/api.ts
+/** Map framework route methods to Kizlo without passing Next.js params as platform context. */
+function toNextJsHandler(handler) {
+	const route = (request) => handler(request);
+	return {
+		GET: route,
+		POST: route,
+		PUT: route,
+		PATCH: route,
+		DELETE: route,
+		OPTIONS: route,
+		HEAD: route
+	};
+}
+
+//#endregion
+export { toNextJsHandler };

package/dist/integrations/tanstack-start/cloudflare/cache-policy.js

@@ -0,0 +1,14 @@
+//#region src/integrations/tanstack-start/cloudflare/cache-policy.ts
+const EDGE_HEADERS = [
+	"Cloudflare-CDN-Cache-Control",
+	"CDN-Cache-Control",
+	"Cache-Control"
+];
+function validateTags(tags) {
+	if (!Array.isArray(tags)) throw new TypeError("CDN tags must be an array of strings.");
+	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)];
+}
+
+//#endregion
+export { EDGE_HEADERS, validateTags };

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

@@ -0,0 +1,40 @@
+import { Duration } from "@kizlo/shared";
+
+//#region src/integrations/tanstack-start/cloudflare/cache.d.ts
+
+interface CloudflareCacheResult {
+  success: boolean;
+  errors?: {
+    code: number;
+    message: string;
+  }[];
+}
+/** Native Workers Cache control surface, not the separate caches.default API. */
+interface CloudflareCacheBinding {
+  invalidate?(options: {
+    tags?: string[];
+    pathPrefixes?: string[];
+  }): Promise<CloudflareCacheResult>;
+  purge?(options: {
+    purgeEverything: true;
+  }): Promise<CloudflareCacheResult>;
+}
+interface CdnHeadersOptions {
+  /** Freshness in seconds at the edge. Browser reuse requires revalidation. */
+  maxAge: Duration;
+  staleWhileRevalidate?: Duration;
+  /** Defaults to zero so a failing origin cannot keep stale pages indefinitely. */
+  staleIfError?: Duration;
+  tags?: readonly string[];
+  /** Request headers that select separate cached responses. No variance is added automatically. */
+  vary?: readonly string[];
+}
+declare function createCdnHeaders(options: CdnHeadersOptions): Record<string, string>;
+/** Mark the native pathname prefix stale, including its query variants and longer paths. */
+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, purgeCache, revalidateTag, revalidateUrl };

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

@@ -0,0 +1,112 @@
+import { getStartRequestContext } from "../request-context.js";
+import { EDGE_HEADERS, validateTags } from "./cache-policy.js";
+import { seconds } from "@kizlo/shared";
+import { createHash } from "node:crypto";
+
+//#region src/integrations/tanstack-start/cloudflare/cache.ts
+function getCacheContext() {
+	const context = getStartRequestContext();
+	const cache = (context?.values)?.executionCtx?.cache;
+	if (!context || !cache) throw new Error("CDN revalidation requires a TanStack Start request with executionCtx.cache. Use withCloudflare at the Worker entrypoint.");
+	return {
+		url: new URL(context.request.url),
+		cache
+	};
+}
+const MAX_TAG_HEADER_BYTES = 16384;
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const resourceTag = (url, tag) => `kizlo:t:${digest(`${url.host}\0${tag}`)}`;
+function seconds$1(value, name) {
+	value = typeof value === "number" ? value : seconds(value);
+	if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a nonnegative integer number of seconds.`);
+	return value;
+}
+function createCdnHeaders(options) {
+	const directives = [`public`, `max-age=${seconds$1(options.maxAge, "maxAge")}`];
+	if (options.staleWhileRevalidate !== void 0) directives.push(`stale-while-revalidate=${seconds$1(options.staleWhileRevalidate, "staleWhileRevalidate")}`);
+	directives.push(`stale-if-error=${seconds$1(options.staleIfError ?? 0, "staleIfError")}`);
+	const tags = validateTags(options.tags ?? []).join(",");
+	const vary = options.vary ?? [];
+	if (!Array.isArray(vary) || vary.some((name) => typeof name !== "string" || !name.length || /[^!#$%&'*+.^_`|~0-9a-z-]/i.test(name))) throw new TypeError("Vary must be an array of HTTP header names.");
+	const names = [...new Map(vary.map((name) => [name.toLowerCase(), name])).values()];
+	return {
+		"Cache-Control": "no-cache",
+		"Cloudflare-CDN-Cache-Control": directives.join(", "),
+		...tags ? { "Cache-Tag": tags } : {},
+		...names.length ? { Vary: names.includes("*") ? "*" : names.join(", ") } : {}
+	};
+}
+/** Mark the native pathname prefix stale, including its query variants and longer paths. */
+async function revalidateUrl(url) {
+	const state = getCacheContext();
+	const value = url instanceof URL ? url.href : url;
+	if (typeof value !== "string" || !/^(?:\/(?!\/)|https?:\/\/)/i.test(value) || /[\s\p{Cc}\\]/u.test(value)) throw new TypeError("CDN URLs must be absolute pathnames or same-origin HTTP(S) URLs without whitespace or backslashes.");
+	const target = new URL(value, state.url);
+	if (target.origin !== state.url.origin || target.username || target.password) throw new TypeError("CDN URLs must belong to the current origin and cannot contain credentials.");
+	await invalidate(state.cache, { pathPrefixes: [target.pathname] });
+}
+/** 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();
+	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().");
+	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}` : "."}`);
+	}
+}
+/** Default to no caching and encode only authored resource tags. */
+function applyCloudflareHeaders(request, response) {
+	if (response.status === 101) return response;
+	const result = new Headers(response.headers);
+	if (!EDGE_HEADERS.some((name) => result.has(name))) result.set("Cache-Control", "no-store");
+	const authoredTags = result.get("Cache-Tag");
+	if (authoredTags !== null) {
+		const url = new URL(request.url);
+		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, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: result
+	});
+}
+
+//#endregion
+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/cookies.js

@@ -0,0 +1,20 @@
+import { deleteCookie, getCookies, setCookie } from "@tanstack/react-start/server";
+
+//#region src/integrations/tanstack-start/react/cookies.ts
+function startCookies() {
+	return {
+		getAll: () => Object.entries(getCookies()).flatMap(([name, value]) => value === void 0 ? [] : [{
+			name,
+			value
+		}]),
+		setAll: (cookies) => {
+			for (const { name, value, options } of cookies) setCookie(name, value, options);
+		},
+		deleteAll: (cookies) => {
+			for (const { name, options } of cookies) deleteCookie(name, options);
+		}
+	};
+}
+
+//#endregion
+export { startCookies };

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

@@ -0,0 +1,25 @@
+import { CookiesAdapter } from "../../../shared/types.js";
+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";
+
+//#region src/integrations/tanstack-start/react/integration.d.ts
+/** Add React Start's native request context and cookies to the shared environment mapping. */
+declare function tanstackStart(options?: TanstackStartOptions): {
+  adapters: {
+    cookies: CookiesAdapter;
+    requestContext: {
+      get: typeof getStartRequestContext;
+    };
+  };
+  id: "tanstack-start";
+  procedures?: Record<never, never> | undefined;
+  events?: EventHandler[];
+  env?: EnvSource;
+  requires?: IntegrationRequirements;
+  order?: number;
+};
+//#endregion
+export { tanstackStart };