kizlo 0.10.0 → 0.12.0

package/dist/cli/presets/source.js

@@ -4,36 +4,39 @@ import os from "node:os";
 import { downloadTemplate } from "giget";
 
 //#region src/cli/presets/source.ts
-/** GitHub repo the templates are fetched from. */
-const TEMPLATE_REPO = "github:kizlo-io/kizlo";
-/**
-* Resolve where a template is fetched from. Defaults to the templates on the repo's default branch:
-* the template is decoupled from the CLI version — it declares its own `kizlo` dependency — so there
-* is no tag to match and no release to cut. `KIZLO_TEMPLATE_LOCAL_DIR` points at a local `templates/`
-* directory so development (and `create`/`init` tests) never touch the network.
-*/
-function templateSource(template) {
-	const localDir = process.env.KIZLO_TEMPLATE_LOCAL_DIR;
-	if (localDir) return { local: path.resolve(localDir, template) };
-	return { remote: `${TEMPLATE_REPO}/templates/${template}` };
+/** The default registry: the templates workspace on the repo's default branch. */
+const DEFAULT_REGISTRY = "github:kizlo-io/kizlo/templates";
+function resolveRegistry(registryArg) {
+	if (!registryArg) return {
+		local: false,
+		source: DEFAULT_REGISTRY
+	};
+	const abs = path.resolve(registryArg);
+	if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) return {
+		local: true,
+		source: abs
+	};
+	return {
+		local: false,
+		source: registryArg
+	};
 }
 /**
-* Get the template as a readable directory both `create` and `init` can copy from or read. With
-* `KIZLO_TEMPLATE_LOCAL_DIR` set it's the local folder (returned as-is, cleanup is a no-op). Otherwise
-* it's downloaded once into a fresh temp directory the caller cleans up. The single fetch path shared
-* by both commands, so they can never source different bytes.
+* Get a registry as a readable directory both commands can scan and copy from. A local registry is
+* returned as-is (cleanup is a no-op); a remote one is downloaded once into a fresh temp directory the
+* caller cleans up. The whole registry is fetched in one shot so listing and applying share the same
+* bytes and never re-download per template.
 */
-async function fetchTemplate(template) {
-	const source = templateSource(template);
-	if (source.local) {
-		if (!fs.existsSync(source.local)) throw new Error(`Local template not found: ${source.local}`);
+async function fetchRegistry(registry) {
+	if (registry.local) {
+		if (!fs.existsSync(registry.source)) throw new Error(`Registry directory not found: ${registry.source}`);
 		return {
-			dir: source.local,
+			dir: registry.source,
 			cleanup: () => {}
 		};
 	}
-	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "kizlo-template-"));
-	await downloadTemplate(source.remote, {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "kizlo-registry-"));
+	await downloadTemplate(registry.source, {
 		dir,
 		forceClean: true
 	});
@@ -45,6 +48,101 @@ async function fetchTemplate(template) {
 		})
 	};
 }
+/** The display fields from a raw `template.json`, read leniently so one bad manifest can't break discovery. */
+function readMeta(manifestPath) {
+	try {
+		const raw = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+		return {
+			name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : void 0,
+			framework: typeof raw.framework === "string" && raw.framework.trim() ? raw.framework.trim() : void 0
+		};
+	} catch {
+		return {};
+	}
+}
+/**
+* Every template a fetched registry contains. A registry can be either shape, and both "just work":
+*
+* - A collection: a directory of templates, each an immediate subdirectory with its own `template.json`
+*   (Kizlo's own `templates/` dir, or a community registry of several). The subdirectory name is the
+*   template's addressable id. A subdirectory without a manifest is skipped so an unrelated folder can't
+*   break the listing.
+* - A single template: a directory that is itself a template (`template.json` at its root) — the escape
+*   hatch for a community template shipped on its own, e.g. `--source github:acme/kizlo-astro-template`.
+*   Its id comes from the manifest's `framework` (a stable name that also matches what `init`'s detected
+*   preset asks for), not the directory name, which for a downloaded repo is a random temp folder.
+*
+* Discovery is by scanning, not a hardcoded list, and the manifest is read only for its display fields
+* here. Sorted by id for a stable prompt order.
+*/
+/**
+* True when the fetched source is itself a single template (a `template.json` at its root) rather than a
+* registry of many. `init` uses this to tell the two `--source` shapes apart: a single template is an
+* explicit, deliberate choice (applied even against detection, with a warning), whereas a registry is
+* filtered down to the templates whose framework the project matches.
+*/
+function isSingleTemplate(registryDir) {
+	return fs.existsSync(path.join(registryDir, "template.json"));
+}
+function listTemplates(registryDir) {
+	if (!fs.existsSync(registryDir)) return [];
+	if (isSingleTemplate(registryDir)) {
+		const meta = readMeta(path.join(registryDir, "template.json"));
+		const id = meta.framework ?? path.basename(registryDir);
+		return [{
+			id,
+			label: meta.name ?? meta.framework ?? id,
+			dir: registryDir
+		}];
+	}
+	const entries = [];
+	for (const dirent of fs.readdirSync(registryDir, { withFileTypes: true })) {
+		if (!dirent.isDirectory()) continue;
+		const dir = path.join(registryDir, dirent.name);
+		const manifestPath = path.join(dir, "template.json");
+		if (!fs.existsSync(manifestPath)) continue;
+		const meta = readMeta(manifestPath);
+		entries.push({
+			id: dirent.name,
+			label: meta.name ?? meta.framework ?? dirent.name,
+			dir
+		});
+	}
+	return entries.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** A template's detection dependency list, read leniently so one bad manifest can't break detection. */
+function readDetectDeps(templateDir) {
+	try {
+		const deps = JSON.parse(fs.readFileSync(path.join(templateDir, "template.json"), "utf8")).detect?.dependencies;
+		return Array.isArray(deps) ? deps.filter((name) => typeof name === "string") : [];
+	} catch {
+		return [];
+	}
+}
+/**
+* The templates whose framework a project is built with, best match(es) first, or an empty array when
+* none matches (use the base fallback). Detection is data: each template's manifest declares the
+* `detect.dependencies` whose presence in the project's deps identify its framework, and this scores
+* every entry by how many of its declared deps the project has, returning every entry that ties for the
+* top score. One match is the common one-per-framework registry; more than one means the registry ships
+* same-framework variants that dependency presence alone can't disambiguate, and the caller decides
+* (prompt, or force with `--template`). Ties preserve the entries' incoming order (id-sorted from
+* {@link listTemplates}). Read leniently — a malformed manifest scores zero rather than throwing — so one
+* bad template in a registry can't break detection for the rest.
+*/
+function detectTemplates(entries, deps) {
+	let bestScore = 0;
+	let best = [];
+	for (const entry of entries) {
+		const score = readDetectDeps(entry.dir).filter((name) => name in deps).length;
+		if (score === 0) continue;
+		if (score > bestScore) {
+			bestScore = score;
+			best = [entry];
+		} else if (score === bestScore) best.push(entry);
+	}
+	return best;
+}
 
 //#endregion
-export { fetchTemplate };
+export { DEFAULT_REGISTRY, detectTemplates, fetchRegistry, isSingleTemplate, listTemplates, resolveRegistry };

package/dist/cli/presets/template.js

@@ -8,17 +8,25 @@ import fs from "node:fs";
 /**
 * The template's `template.json`. It is the single declaration of what Kizlo lays onto a project and
 * how — the same engine drives both `create` (onto a fresh app the framework CLI just bootstrapped)
-* and `init` (onto the user's existing project). Changes are grouped into three sections so a command
-* only ever applies what is safe for it:
+* and `init` (onto the user's existing project). Changes are grouped into three sections by the one
+* question that decides whether a command may safely apply them — *where is this safe to land?* — and
+* no command ever reads another command's section:
 *
-* - `base` — applied by both commands: the Kizlo plumbing (server entry, client, routes). Every
-*   change here must be safe on an existing project, so it is limited to files Kizlo owns, which
-*   never collide with the user's pages.
-* - `create` — applied only by `create`, onto a freshly bootstrapped app it may freely overwrite:
-*   the root layout (written whole, already SEO-wired) and its styles as core wiring, plus the demo
-*   pages flagged `example`, which are written only when the user asks for example pages.
-* - `init` — applied only by `init`, onto the user's existing project. The root-layout SEO wiring
-*   lands here as a `patch` so it merges into the layout the user already owns instead of replacing it.
+* - `base` — safe on any project: additive, Kizlo-owned paths that never collide with the user's own
+*   files (the server entry, client, routes, and additive demo pages like a new blog route). Applied
+*   by both commands.
+* - `create` — safe only on a freshly bootstrapped app `create` may freely overwrite: the files the
+*   framework CLI already scaffolded, like the root layout (written whole, SEO-wired) and the homepage
+*   showcase. Applied only by `create`, never `init` — overwriting these on a real project would
+*   clobber the user's work.
+* - `init` — the non-destructive counterpart for the user's existing project: the root-layout SEO
+*   wiring lands here as a `patch` that merges into the layout the user already owns.
+*
+* Cutting across all three is the orthogonal `example` flag: opt-in demo content, applied only when the
+* user answers yes to "Add example pages?". A cross-cutting example (e.g. a blog) files each of its
+* pieces in the section that matches its safety — the additive new route in `base`, the homepage
+* showcase that overwrites an app-owned file in `create` — so `init` picks up only the additive half and
+* never touches a file the user owns, while `create` gets the whole demo. See {@link changesFor}.
 *
 * Each section is a list of changes, every one a member of a small closed set — deliberately no
 * "patch an arbitrary source file" kind, so a dangerous strategy is unrepresentable:
@@ -83,18 +91,61 @@ const envSchema = z.object({
 });
 /** A package name → version-range map, package.json's own vocabulary. */
 const depsSchema = z.record(z.string(), z.string());
+/**
+* The package names whose presence in a project's dependencies identify this framework — how `init`
+* recognizes which template to apply to an existing project (e.g. `["next"]`, `["astro"]`). Detection is
+* data, so a community template declares its own signal and needs no CLI change. See {@link detectTemplate}.
+*/
+const detectSchema = z.object({ dependencies: z.array(z.string()).default([]) });
+/**
+* An `init` precondition on the project's shape: at least one of `anyDir` must exist in the project,
+* else `init` stops with `message`. Replaces framework-specific `if` branches — e.g. Next.js needs an
+* `app` or `src/app` directory (the App Router), which the Pages Router lacks. Dormant when absent.
+*/
+const requiresSchema = z.object({
+	anyDir: z.array(z.string()),
+	message: z.string()
+});
+/**
+* A post-setup manual step `init` prints after wiring — the piece Kizlo can't auto-wire into a file the
+* user owns (e.g. Astro's SEO tags render through a `.astro` component, not a patchable export). `create`
+* owns files whole, so it never prints these. `body` may carry one token, `{{importPrefix}}`, substituted
+* by {@link renderNote} with the project's source-root import prefix (an alias like `@/`, else `../`).
+*/
+const noteSchema = z.object({
+	title: z.string(),
+	body: z.string()
+});
 const manifestSchema = z.object({
 	framework: z.string(),
+	name: z.string().optional(),
 	env: envSchema.optional(),
 	dependencies: depsSchema.optional(),
 	devDependencies: depsSchema.optional(),
 	minCli: z.string().optional(),
+	apiPath: z.string().optional(),
+	detect: detectSchema.optional(),
+	requires: requiresSchema.optional(),
+	notes: z.array(noteSchema).default([]),
 	bootstrap: bootstrapSchema.optional(),
 	conventions: conventionsSchema,
 	base: z.array(changeSchema).default([]),
 	create: z.array(changeSchema).default([]),
 	init: z.array(changeSchema).default([])
 });
+/**
+* Render a manual-step note for display, substituting the `{{importPrefix}}` token with the project's
+* source-root import prefix — the configured alias (normalized to a trailing slash, e.g. `@/`) when one
+* is set, else the relative `../`. Reproduces the old `alias ? "@/…" : "../…"` behavior exactly, so a
+* template's note reads correctly whichever import style the project uses.
+*/
+function renderNote(note, alias) {
+	const importPrefix = alias ? `${alias.replace(/\/+$/, "")}/` : "../";
+	return {
+		title: note.title,
+		body: note.body.replaceAll("{{importPrefix}}", importPrefix)
+	};
+}
 /** Role → the human label init uses in prompts and logs. */
 const ROLE_LABELS = {
 	"server-entry": "Kizlo server instance",
@@ -107,6 +158,9 @@ const ROLE_LABELS = {
 	"root-layout": "root layout",
 	"home-page": "home page",
 	"blog-post": "blog post page",
+	"head-component": "SEO head component",
+	"framework-config": "framework config",
+	tsconfig: "TypeScript config",
 	styles: "global styles"
 };
 /** Read and validate the template's manifest from a fetched template directory. */
@@ -162,12 +216,16 @@ function minCliError(manifest) {
 	return `This template needs the kizlo CLI >= ${manifest.minCli} (you have ${running}). Run \`npx kizlo@latest\` and try again.`;
 }
 /**
-* The changes a command applies: the shared `base` set plus the command's own section. `create` gets
-* `base + create` (plumbing plus the demo pages); `init` gets `base + init` (plumbing plus any
-* init-only surgical patches). `base` is applied first so a later section can override it.
+* The changes a command applies: the shared `base` set plus the command's own section (`base` first, so
+* a later section can override it). Section placement is the *safety* axis — `base` is additive and safe
+* on any project, `create`/`init` carry the fresh-app-vs-existing-project halves — while the `example`
+* flag is the orthogonal *opt-in* axis. Example changes are dropped unless `includeExamples`, so the same
+* call serves both "core wiring only" and "plus the demo pages", and each command only ever sees its own
+* section: init's opt-in examples are the additive ones in `base`, never create's homepage overwrite.
 */
-function changesFor(manifest, command) {
-	return [...manifest.base, ...manifest[command]];
+function changesFor(manifest, command, opts = {}) {
+	const changes = [...manifest.base, ...manifest[command]];
+	return opts.includeExamples ? changes : changes.filter((change) => !isExample(change));
 }
 /** The whole-file changes in a resolved change list. */
 function fileEntries(changes) {
@@ -177,7 +235,7 @@ function fileEntries(changes) {
 function patchEntries(changes) {
 	return changes.filter((change) => change.kind === "patch");
 }
-/** Whether a change is opt-in demo content — written by `create` only when example pages are requested. */
+/** Whether a change is opt-in demo content — applied only when example pages are requested. */
 function isExample(change) {
 	return change.kind === "file" && change.example === true;
 }
@@ -267,4 +325,4 @@ function rendersHtml(file) {
 }
 
 //#endregion
-export { adaptFile, changesFor, fileEntries, findRootLayout, isExample, isOlderVersion, minCliError, patchEntries, readManifest, resolveDependencies, resolvePatch };
+export { adaptFile, changesFor, fileEntries, findRootLayout, isOlderVersion, minCliError, patchEntries, readManifest, renderNote, resolveDependencies, resolvePatch };

package/dist/cli/wp/settings.js

@@ -1,5 +1,6 @@
 import { WP_KIZLO_BASE } from "../../wordpress/constants.js";
 import { WordPressService } from "../../wordpress/service.js";
+import { PLUGIN_VERSION_HEADER } from "@kizlo/shared";
 
 //#region src/cli/wp/settings.ts
 /** Loopback hosts that, from inside the dev Docker stack, must be rewritten to reach the host. */
@@ -52,11 +53,16 @@ async function syncSiteSettings(credentials, settings) {
 		base: WP_KIZLO_BASE,
 		body
 	});
+	const pluginVersion = response.headers.get(PLUGIN_VERSION_HEADER);
 	if (response.error) return {
 		ok: false,
-		error: describeError(response.status, response.error)
+		error: describeError(response.status, response.error),
+		pluginVersion
+	};
+	return {
+		ok: true,
+		pluginVersion
 	};
-	return { ok: true };
 }
 /**
 * A short, log-friendly summary of a failed request. A transport failure has no HTTP status (`0`), so

package/dist/comment/schema.js

@@ -1,5 +1,5 @@
-import { ListMetadata, ListOrder, Media } from "../shared/schema.js";
-import { NumberLike, arrayable } from "@kizlo/shared";
+import { ListMetadata, ListOrder } from "../shared/schema.js";
+import { Media, NumberLike, arrayable } from "@kizlo/shared";
 import z from "zod/v4";
 
 //#region src/comment/schema.ts

package/dist/context.d.ts

@@ -60,6 +60,15 @@ declare class Context {
   private readonly settings;
   private readonly email;
   constructor(config: ContextConfig);
+  /**
+   * Warn when the WordPress plugin is older than {@link isPluginVersionSupported} allows, read from the
+   * `X-Kizlo-Version` header the plugin stamps on every response. A version mismatch is a serious
+   * contract break, so this fires on every WordPress response rather than once — the header rides
+   * responses the runtime already makes, so it costs no extra request. Emitted through `console.warn`
+   * rather than the logger adapter on purpose: the adapter is optional (it defaults to a no-op), and
+   * this is a setup problem every user must see regardless of whether they've wired up logging.
+   */
+  private warnIfPluginOutdated;
   createRestContext(request: Request): {
     headers: Headers;
     request: Request;

package/dist/context.js

@@ -5,7 +5,7 @@ import { CookiesStorage } from "./cookie.js";
 import { WordPressService } from "./wordpress/service.js";
 import { EmailService } from "./email/service.js";
 import { SettingsService } from "./settings/service.js";
-import { base64Decode, tryCatchSync } from "@kizlo/shared";
+import { PLUGIN_VERSION_HEADER, base64Decode, isPluginVersionSupported, pluginUpdateMessage, tryCatchSync } from "@kizlo/shared";
 import { serialize } from "cookie";
 
 //#region src/context.ts
@@ -17,11 +17,29 @@ var Context = class {
 	email;
 	constructor(config) {
 		this.config = config;
-		this.wordpress = new WordPressService(config);
+		this.wordpress = new WordPressService({
+			...config,
+			onResponse: (headers) => this.warnIfPluginOutdated(headers)
+		});
 		this.settings = new SettingsService(this.wordpress);
 		this.email = new EmailService(this.wordpress);
 		this.logger = this.createLogger();
 	}
+	/**
+	* Warn when the WordPress plugin is older than {@link isPluginVersionSupported} allows, read from the
+	* `X-Kizlo-Version` header the plugin stamps on every response. A version mismatch is a serious
+	* contract break, so this fires on every WordPress response rather than once — the header rides
+	* responses the runtime already makes, so it costs no extra request. Emitted through `console.warn`
+	* rather than the logger adapter on purpose: the adapter is optional (it defaults to a no-op), and
+	* this is a setup problem every user must see regardless of whether they've wired up logging.
+	*/
+	warnIfPluginOutdated(headers) {
+		const installed = headers.get(PLUGIN_VERSION_HEADER);
+		if (isPluginVersionSupported(installed)) return;
+		const inner = ` ${pluginUpdateMessage(installed)} `;
+		const border = "-".repeat(inner.length + 2);
+		console.warn(`\n\x1b[1m\x1b[33m${border}\n|${inner}|\n${border}\x1b[0m\n`);
+	}
 	createRestContext(request) {
 		const headers = new Headers();
 		return {

package/dist/index.d.ts

@@ -22,7 +22,7 @@ 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 { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, Media, PreviewTokenData, PreviewTokenPayload } from "./shared/schema.js";
+import { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, 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";
 import { ConnInfo, GeoAdapter, GeoGetConnInfo, createGeoAdapter, geoMock } from "./adapters/geo.js";
@@ -39,17 +39,17 @@ import { COMMON_ERRORS, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, Def
 import { AnyMiddleware, ExtractMiddlewareContextOutput, InferMiddlewares, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, createMiddleware } from "./shared/middleware.js";
 import { AnyProcedure, AnyProcedureRouter, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureErrors, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType } from "./shared/procedure.js";
 import { AnyExtension, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtractExtensionRouter, InferExtensionRouter, createExtension } from "./shared/extension.js";
-import { AnyKizloConfig, CreateKizloOptions, Kizlo, KizloConfig, KizloConnect, RootRouter, S2SClient, ServiceAdapters, createKizlo, resolveKizloConfig } from "./kizlo.js";
+import { AnyKizloConfig, CreateKizloOptions, EnvReader, Kizlo, KizloConfig, KizloConnect, RootRouter, S2SClient, ServiceAdapters, createKizlo, resolveKizloConfig } from "./kizlo.js";
 import { WEB_MANIFEST_ROUTE, WebManifest, buildWebManifest, createManifestRoute } from "./brand/manifest.js";
 import "./brand/index.js";
 import { KizloClient, KizloClientConfig, createKizloClient } from "./client.js";
 import { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList } from "./seo/schema.js";
 import { WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage } from "./seo/types.js";
-import { SitemapIndexEntry, deserializeSeo, parseSitemapSlug, renderSitemapIndex, renderUrlSet, sitemapEntryPath, xmlResponse } from "./seo/utils.js";
+import { SitemapIndexEntry, deserializeSeo, parseSitemapSlug, renderJsonLd, renderSitemapIndex, renderUrlSet, sitemapEntryPath, xmlResponse } from "./seo/utils.js";
 import { CreateSitemapRouteOptions, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SitemapRouteExtra, createSitemapRedirectRoute, createSitemapRoute } from "./seo/sitemap.js";
 import { Contract, ContractProcedure, generateContract, isContractProcedure, restoreContract } from "./shared/contract.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, AuthorsSettings, AuthorsSettingsInput, BaseHandlerOptions, BrandSettings, BrandSettingsInput, CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CaptchaAdapter, CategoryService, CommentService, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CookiesStorage, CrawlingSettings, CrawlingSettingsInput, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, Environment, ErrorDefinition, EventHandler, EventHandlerFn, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtractExtensionRouter, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, IconDescriptor, Identifier, IdentifierInput, IdentitySettings, IdentitySettingsInput, InferEventUnion, InferExtensionRouter, InferMiddlewares, InvocationScope, JsonValue, Kizlo, KizloClient, KizloClientConfig, KizloConfig, KizloConnect, KizloError, KizloErrorOptions, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, ManifestIcon, MaybeOptionalOptions, Media, MenuItemService, MenuService, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, PageService, PersonSettings, PersonSettingsInput, PluginSource, PostService, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, ROUTER_MAP, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedIcons, ResolvedSchemaInput, ResolvedSchemaOutput, Robots, RobotsRule, RootRouter, RouterDepthTuple, RouterMap, S2SClient, SAFE_REQUEST_TIMEOUT, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServiceAdapters, Settings, SettingsService, ShaAlgorithm, SiteSettings, SiteSettingsInput, Sitemap, SitemapIndex, SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, SocialProfile, TaxonomySettings, TaxonomySettingsInput, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UNEXPECTED_BODY_SNIPPET_LENGTH, UploadsSettings, UploadsSettingsInput, UserService, VerifyCaptchaFn, VerifyPreviewTokenFn, WC_CORE_BASE, WC_STORE_BASE, WEB_MANIFEST_ROUTE, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CATEGORY_ORDER_BYS, WP_CORE_BASE, WP_Category, WP_CategoryCreateErrorCode, WP_CategoryCreateInput, WP_CategoryDeleteErrorCode, WP_CategoryDeleteInput, WP_CategoryDeleteResponse, WP_CategoryLinks, WP_CategoryListErrorCode, WP_CategoryListInput, WP_CategoryOrderBy, WP_CategoryRetrieveErrorCode, WP_CategoryRetrieveInput, WP_CategoryTaxonomy, WP_CategoryUpdateErrorCode, WP_CategoryUpdateInput, 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_ITEM_ORDER_BYES, WP_MENU_ITEM_TARGETS, WP_MENU_ITEM_TAX_RELATIONS, 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_PAGE_ORDER_BYES, WP_PAGE_STATUSES, WP_POST_FORMATS, WP_POST_ORDER_BYES, WP_POST_STATUSES, WP_POST_TAX_RELATIONS, WP_Page, WP_PageCommentStatus, WP_PageContent, WP_PageContentInput, WP_PageCreateErrorCode, WP_PageCreateInput, WP_PageDeleteErrorCode, WP_PageDeleteInput, WP_PageDeleteResponse, WP_PageExcerpt, WP_PageExcerptInput, WP_PageGuid, WP_PageLinks, WP_PageListErrorCode, WP_PageListInput, WP_PageOrderBy, WP_PageRetrieveErrorCode, WP_PageRetrieveInput, WP_PageStatus, WP_PageStatusFilter, WP_PageTitle, WP_PageTitleInput, WP_PageUpdateErrorCode, WP_PageUpdateInput, 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_TAG_ORDER_BYS, WP_Tag, WP_TagCreateErrorCode, WP_TagCreateInput, WP_TagDeleteErrorCode, WP_TagDeleteInput, WP_TagDeleteResponse, WP_TagLinks, WP_TagListErrorCode, WP_TagListInput, WP_TagOrderBy, WP_TagRetrieveErrorCode, WP_TagRetrieveInput, WP_TagTaxonomy, WP_TagUpdateErrorCode, WP_TagUpdateInput, 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, WebManifest, WebhookOptions, WebhookSettings, WebhookSettingsInput, WithCommonErrorMap, WordPressCredentials, WordPressService, altcha, arkose, authMock, buildProcedure, buildWebManifest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, parseSitemapSlug, recaptcha, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, xmlResponse };
+export { AnyContext, AnyEventSchema, AnyEvents, AnyExtension, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureRouter, AuthAdapter, AuthGetUser, AuthUser, AuthUserFn, AuthorsSettings, AuthorsSettingsInput, BaseHandlerOptions, BrandSettings, BrandSettingsInput, CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CaptchaAdapter, CategoryService, CommentService, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CookiesStorage, CrawlingSettings, CrawlingSettingsInput, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, EnvReader, Environment, ErrorDefinition, EventHandler, EventHandlerFn, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtractExtensionRouter, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, IconDescriptor, Identifier, IdentifierInput, IdentitySettings, IdentitySettingsInput, InferEventUnion, InferExtensionRouter, InferMiddlewares, InvocationScope, JsonValue, Kizlo, KizloClient, KizloClientConfig, KizloConfig, KizloConnect, KizloError, KizloErrorOptions, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, ManifestIcon, MaybeOptionalOptions, MenuItemService, MenuService, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, PageService, PersonSettings, PersonSettingsInput, PluginSource, PostService, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, ROUTER_MAP, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedIcons, ResolvedSchemaInput, ResolvedSchemaOutput, Robots, RobotsRule, RootRouter, RouterDepthTuple, RouterMap, S2SClient, SAFE_REQUEST_TIMEOUT, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServiceAdapters, Settings, SettingsService, ShaAlgorithm, SiteSettings, SiteSettingsInput, Sitemap, SitemapIndex, SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, SocialProfile, TaxonomySettings, TaxonomySettingsInput, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UNEXPECTED_BODY_SNIPPET_LENGTH, UploadsSettings, UploadsSettingsInput, UserService, VerifyCaptchaFn, VerifyPreviewTokenFn, WC_CORE_BASE, WC_STORE_BASE, WEB_MANIFEST_ROUTE, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CATEGORY_ORDER_BYS, WP_CORE_BASE, WP_Category, WP_CategoryCreateErrorCode, WP_CategoryCreateInput, WP_CategoryDeleteErrorCode, WP_CategoryDeleteInput, WP_CategoryDeleteResponse, WP_CategoryLinks, WP_CategoryListErrorCode, WP_CategoryListInput, WP_CategoryOrderBy, WP_CategoryRetrieveErrorCode, WP_CategoryRetrieveInput, WP_CategoryTaxonomy, WP_CategoryUpdateErrorCode, WP_CategoryUpdateInput, 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_ITEM_ORDER_BYES, WP_MENU_ITEM_TARGETS, WP_MENU_ITEM_TAX_RELATIONS, 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_PAGE_ORDER_BYES, WP_PAGE_STATUSES, WP_POST_FORMATS, WP_POST_ORDER_BYES, WP_POST_STATUSES, WP_POST_TAX_RELATIONS, WP_Page, WP_PageCommentStatus, WP_PageContent, WP_PageContentInput, WP_PageCreateErrorCode, WP_PageCreateInput, WP_PageDeleteErrorCode, WP_PageDeleteInput, WP_PageDeleteResponse, WP_PageExcerpt, WP_PageExcerptInput, WP_PageGuid, WP_PageLinks, WP_PageListErrorCode, WP_PageListInput, WP_PageOrderBy, WP_PageRetrieveErrorCode, WP_PageRetrieveInput, WP_PageStatus, WP_PageStatusFilter, WP_PageTitle, WP_PageTitleInput, WP_PageUpdateErrorCode, WP_PageUpdateInput, 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_TAG_ORDER_BYS, WP_Tag, WP_TagCreateErrorCode, WP_TagCreateInput, WP_TagDeleteErrorCode, WP_TagDeleteInput, WP_TagDeleteResponse, WP_TagLinks, WP_TagListErrorCode, WP_TagListInput, WP_TagOrderBy, WP_TagRetrieveErrorCode, WP_TagRetrieveInput, WP_TagTaxonomy, WP_TagUpdateErrorCode, WP_TagUpdateInput, 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, WebManifest, WebhookOptions, WebhookSettings, WebhookSettingsInput, WithCommonErrorMap, WordPressCredentials, WordPressService, altcha, arkose, authMock, buildProcedure, buildWebManifest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, parseSitemapSlug, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, xmlResponse };

package/dist/index.js

@@ -12,7 +12,7 @@ import { COMMON_ERRORS, KizloError, createThrowableErrorMap, defineErrorMap, isK
 import { buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType } from "./shared/procedure.js";
 import { createOrpcRouter } from "./shared/router.js";
 import { generateContract, isContractProcedure, restoreContract } from "./shared/contract.js";
-import { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, Media, PreviewTokenData, PreviewTokenPayload } from "./shared/schema.js";
+import { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, PreviewTokenData, PreviewTokenPayload } from "./shared/schema.js";
 import { KizloClient, createKizloClient } from "./client.js";
 import { CookiesStorage } from "./cookie.js";
 import { CART_HASH_HEADER_KEY, SAFE_REQUEST_TIMEOUT, UNEXPECTED_BODY_SNIPPET_LENGTH, WC_CORE_BASE, WC_STORE_BASE, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CORE_BASE, WP_KIZLO_BASE } from "./wordpress/constants.js";
@@ -36,7 +36,7 @@ import { Context } from "./context.js";
 import { parseIdentifier } from "./shared/identifier.js";
 import { deserializeCurrencyFormat, deserializeListMetadata, emptyList, serializeCurrencyFormat } from "./shared/serialize.js";
 import { CONTENT_TYPES, ContentType, ListSitemapUrlInput, ListSitemapUrlInputBase, Robots, RobotsRule, Seo, SeoHead, SeoSchema, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList } from "./seo/schema.js";
-import { deserializeSeo, parseSitemapSlug, renderSitemapIndex, renderUrlSet, sitemapEntryPath, xmlResponse } from "./seo/utils.js";
+import { deserializeSeo, parseSitemapSlug, renderJsonLd, renderSitemapIndex, renderUrlSet, sitemapEntryPath, xmlResponse } from "./seo/utils.js";
 import { ROUTER_MAP } from "./router.js";
 import { createEventHandler, createWebhookRouter } from "./webhook/index.js";
 import { Kizlo, createKizlo, resolveKizloConfig } from "./kizlo.js";
@@ -44,4 +44,4 @@ import { SITEMAP_BASE, SITEMAP_INDEX_SLUG, createSitemapRedirectRoute, createSit
 import { createExtension } from "./shared/extension.js";
 import { createMiddleware } from "./shared/middleware.js";
 
-export { CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CategoryService, CommentService, ContentType, Context, CookiesStorage, CurrencyFormat, IdentifierInput, Kizlo, KizloClient, KizloError, LIST_ORDER, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, Media, MenuItemService, MenuService, PageService, PostService, PreviewTokenData, PreviewTokenPayload, ROUTER_MAP, Robots, RobotsRule, SAFE_REQUEST_TIMEOUT, SITEMAP_BASE, SITEMAP_INDEX_SLUG, Seo, SeoHead, SeoSchema, SettingsService, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, UNEXPECTED_BODY_SNIPPET_LENGTH, UserService, WC_CORE_BASE, WC_STORE_BASE, WEB_MANIFEST_ROUTE, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CATEGORY_ORDER_BYS, WP_CORE_BASE, WP_Error, WP_KIZLO_BASE, WP_MENU_ITEM_ORDER_BYES, WP_MENU_ITEM_TARGETS, WP_MENU_ITEM_TAX_RELATIONS, WP_PAGE_ORDER_BYES, WP_PAGE_STATUSES, WP_POST_FORMATS, WP_POST_ORDER_BYES, WP_POST_STATUSES, WP_POST_TAX_RELATIONS, WP_TAG_ORDER_BYS, WordPressService, altcha, arkose, authMock, buildProcedure, buildWebManifest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, parseSitemapSlug, recaptcha, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, xmlResponse };
+export { CART_HASH_HEADER_KEY, COMMON_ERRORS, CONTENT_TYPES, CategoryService, CommentService, ContentType, Context, CookiesStorage, CurrencyFormat, IdentifierInput, Kizlo, KizloClient, KizloError, LIST_ORDER, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, MenuItemService, MenuService, PageService, PostService, PreviewTokenData, PreviewTokenPayload, ROUTER_MAP, Robots, RobotsRule, SAFE_REQUEST_TIMEOUT, SITEMAP_BASE, SITEMAP_INDEX_SLUG, Seo, SeoHead, SeoSchema, SettingsService, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, UNEXPECTED_BODY_SNIPPET_LENGTH, UserService, WC_CORE_BASE, WC_STORE_BASE, WEB_MANIFEST_ROUTE, WP_AUTH_HEADER_KEY, WP_AUTH_TYPE, WP_CATEGORY_ORDER_BYS, WP_CORE_BASE, WP_Error, WP_KIZLO_BASE, WP_MENU_ITEM_ORDER_BYES, WP_MENU_ITEM_TARGETS, WP_MENU_ITEM_TAX_RELATIONS, WP_PAGE_ORDER_BYES, WP_PAGE_STATUSES, WP_POST_FORMATS, WP_POST_ORDER_BYES, WP_POST_STATUSES, WP_POST_TAX_RELATIONS, WP_TAG_ORDER_BYS, WordPressService, altcha, arkose, authMock, buildProcedure, buildWebManifest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createExtension, createGeoAdapter, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, noopAdapter, parseIdentifier, parseSitemapSlug, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, xmlResponse };

package/dist/integrations/astro/kizlo.client.d.ts

@@ -0,0 +1,15 @@
+import { AnyProcedureRouter } from "../../shared/procedure.js";
+import { KizloClient } from "../../client.js";
+
+//#region src/integrations/astro/kizlo.client.d.ts
+interface KizloClientOptions {
+  /**
+   * Backend URL. In the browser, pass `import.meta.env.PUBLIC_KIZLO_API_URL` at the call site so Vite
+   * inlines it into the client bundle (see the template's `client.ts`); when omitted it falls back to
+   * `PUBLIC_KIZLO_API_URL` from `process.env`.
+   */
+  url?: string;
+}
+declare function createKizloClient<T extends AnyProcedureRouter>(contract: T, options?: KizloClientOptions): KizloClient<T>;
+//#endregion
+export { KizloClientOptions, createKizloClient };

package/dist/integrations/astro/kizlo.client.js

@@ -0,0 +1,13 @@
+import { KizloClient } from "../../client.js";
+import { getServerBaseUrl } from "./utils.js";
+
+//#region src/integrations/astro/kizlo.client.ts
+function createKizloClient(contract, options) {
+	return new KizloClient({
+		url: options?.url ?? getServerBaseUrl(),
+		contract
+	});
+}
+
+//#endregion
+export { createKizloClient };

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

@@ -0,0 +1,10 @@
+import { AnyExtension } from "../../shared/extension.js";
+import { CreateKizloOptions, EnvReader, Kizlo } from "../../kizlo.js";
+
+//#region src/integrations/astro/kizlo.server.d.ts
+type KizloServerOptions<TExts extends readonly AnyExtension[] = []> = CreateKizloOptions<TExts> & {
+  getSecret: EnvReader;
+};
+declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options: KizloServerOptions<TExts>): Kizlo<TExts>;
+//#endregion
+export { KizloServerOptions, createKizlo };

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

@@ -0,0 +1,12 @@
+import { Kizlo, resolveKizloConfig } from "../../kizlo.js";
+
+//#region src/integrations/astro/kizlo.server.ts
+function createKizlo(options) {
+	return new Kizlo(resolveKizloConfig(options, {
+		baseUrlEnvKey: "PUBLIC_KIZLO_API_URL",
+		env: options?.getSecret
+	}));
+}
+
+//#endregion
+export { createKizlo };

package/dist/integrations/astro/manifest.d.ts

@@ -0,0 +1,9 @@
+import { S2SClient } from "../../kizlo.js";
+import { WEB_MANIFEST_ROUTE } from "../../brand/manifest.js";
+import { AstroRoute } from "./utils.js";
+
+//#region src/integrations/astro/manifest.d.ts
+/** Astro endpoint for `src/pages/site.webmanifest.ts`. SSR refetches live on each request. */
+declare function createManifestRoute(client: S2SClient<[]>): AstroRoute;
+//#endregion
+export { createManifestRoute };

package/dist/integrations/astro/manifest.js

@@ -0,0 +1,11 @@
+import { WEB_MANIFEST_ROUTE, createManifestRoute } from "../../brand/manifest.js";
+
+//#region src/integrations/astro/manifest.ts
+/** Astro endpoint for `src/pages/site.webmanifest.ts`. SSR refetches live on each request. */
+function createManifestRoute$1(client) {
+	const handler = createManifestRoute(client);
+	return (context) => handler(context.request);
+}
+
+//#endregion
+export { createManifestRoute$1 as createManifestRoute };