kizlo 0.11.0 → 0.12.0

package/dist/cli/daemon/generate.js

@@ -1,8 +1,8 @@
 import { generateContract } from "../../shared/contract.js";
 import { loadEnvFiles } from "../utils.js";
+import { importIgnoringVirtualModules } from "./jiti.js";
 import path from "node:path";
 import fs from "node:fs";
-import { createJiti } from "jiti";
 
 //#region src/cli/daemon/generate.ts
 /** The generated contract barrel — also written as a stub by `kizlo init`. */
@@ -25,9 +25,8 @@ function atomicWrite(file, data) {
 */
 async function generateOnce(cfg) {
 	loadEnvFiles(cfg.cwd);
-	const jiti = createJiti(cfg.cwd, { moduleCache: false });
 	const entry = path.resolve(cfg.cwd, cfg.serverEntry);
-	const { router } = await jiti.import(entry);
+	const { router } = await importIgnoringVirtualModules(cfg.cwd, entry);
 	if (!router) return false;
 	const contract = JSON.stringify(await generateContract(router));
 	fs.mkdirSync(path.resolve(cfg.cwd, cfg.generatedDir), { recursive: true });

package/dist/cli/daemon/jiti.js

@@ -0,0 +1,101 @@
+import { CONTRACT_GENERATION_ENV } from "../../shared/constants.js";
+import path from "node:path";
+import fs from "node:fs";
+import { createJiti } from "jiti";
+
+//#region src/cli/daemon/jiti.ts
+/**
+* Loads a TypeScript module through jiti while tolerating framework virtual modules
+* (`astro:env/server`, `virtual:*`, `#imports`, `$env/*`, …). These are synthesized by the
+* framework's bundler at build time and don't exist on disk, so jiti can't resolve them — but
+* contract generation only needs the module's exported *shape*, never the runtime values a
+* virtual module carries. We discover them from the project's own source rather than maintaining
+* a per-framework list: import, and whenever jiti reports a missing module, stub it and retry.
+*
+* A virtual module is distinguished from a genuinely missing dependency by the one property that
+* always holds — a virtual module is never a declared dependency, so a bare specifier whose
+* package isn't in `package.json` is treated as virtual, while a declared-but-unresolvable
+* dependency is surfaced as the real error it is.
+*/
+async function importIgnoringVirtualModules(cwd, entry) {
+	const deps = declaredDeps(cwd);
+	const virtualModules = {};
+	const previousGenerationFlag = process.env[CONTRACT_GENERATION_ENV];
+	process.env[CONTRACT_GENERATION_ENV] = "1";
+	try {
+		return await importLoop(cwd, entry, deps, virtualModules);
+	} finally {
+		if (previousGenerationFlag === void 0) delete process.env[CONTRACT_GENERATION_ENV];
+		else process.env[CONTRACT_GENERATION_ENV] = previousGenerationFlag;
+	}
+}
+async function importLoop(cwd, entry, deps, virtualModules) {
+	for (;;) {
+		const jiti = createJiti(cwd, {
+			moduleCache: false,
+			tsconfigPaths: true,
+			virtualModules
+		});
+		try {
+			return await jiti.import(entry);
+		} catch (error) {
+			const spec = missingSpecifier(error);
+			if (!spec || !isBareSpecifier(spec) || spec in virtualModules || deps.has(packageNameOf(spec))) throw error;
+			virtualModules[spec] = makeVirtualStub();
+		}
+	}
+}
+/**
+* A no-op module namespace that satisfies any import shape (named, default, nested, callable),
+* so a virtual module can be stubbed without knowing what it exports. The `has` trap is required:
+* without it jiti's `interopDefault` sees a truthy `.default` and routes named lookups down a path
+* that misses.
+*
+* Every export — named, default, nested, callable — is a no-op, so contract generation only ever
+* reads the module's shape, never a real value a virtual module would carry at runtime.
+*/
+function makeVirtualStub() {
+	const stub = new Proxy(() => {}, {
+		apply: () => void 0,
+		has: (_t, prop) => typeof prop === "string" && prop !== "then",
+		get: (_t, prop) => {
+			if (prop === "__esModule") return true;
+			if (prop === "then") return void 0;
+			if (typeof prop === "symbol") return void 0;
+			return stub;
+		}
+	});
+	return stub;
+}
+/** Names of every declared dependency; empty when `package.json` is absent or unreadable. */
+function declaredDeps(cwd) {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+		return new Set([
+			...Object.keys(pkg.dependencies ?? {}),
+			...Object.keys(pkg.devDependencies ?? {}),
+			...Object.keys(pkg.peerDependencies ?? {}),
+			...Object.keys(pkg.optionalDependencies ?? {})
+		]);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/** The specifier jiti/Node reported unresolvable, or undefined when the error isn't a resolution failure. */
+function missingSpecifier(error) {
+	const err = error;
+	if (err?.code !== "MODULE_NOT_FOUND" && err?.code !== "ERR_MODULE_NOT_FOUND") return void 0;
+	return /Cannot find module '([^']+)'/.exec(err.message ?? "")?.[1];
+}
+/** Virtual specifiers are always bare; a missing relative/absolute path is a real bug, not a virtual module. */
+function isBareSpecifier(spec) {
+	return !spec.startsWith(".") && !spec.startsWith("/");
+}
+/** Package name of a bare specifier: `@scope/x/sub` → `@scope/x`, `astro:env/server` → `astro:env`. */
+function packageNameOf(spec) {
+	const parts = spec.split("/");
+	return spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? spec;
+}
+
+//#endregion
+export { importIgnoringVirtualModules };

package/dist/cli/daemon/watch.js

@@ -37,9 +37,9 @@ async function watch(cfg) {
 * Acquire the single-instance lock, generate the contract once, and start the file
 * watcher. Returns a synchronous `stop()` that closes the watcher and releases the
 * lock — or `undefined` when another watcher already holds the lock (a framework dev
-* script, or a second `kizlo dev`), in which case the caller carries on without
-* watching. Used by `kizlo dev`, both when it boots a local stack and when it runs
-* the watcher alone, so a single terminal covers the whole dev loop.
+* script, or a second `kizlo dev`), or when no server `dir` is configured, in which case
+* the caller carries on without watching. Used by `kizlo dev`, both when it boots a local
+* stack and when it runs the watcher alone, so a single terminal covers the whole dev loop.
 */
 async function startWatcher(cwd, opts) {
 	const lock = lockPath(cwd);
@@ -48,6 +48,10 @@ async function startWatcher(cwd, opts) {
 		return;
 	}
 	const cfg = await resolveConfig(cwd, { dir: opts?.dir });
+	if (!cfg) {
+		log.info("skipping the contract generation.");
+		return;
+	}
 	acquire(lock);
 	try {
 		if (await generateOnce(cfg)) log.success("Contract generated");

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

@@ -91,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",
@@ -115,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. */
@@ -279,4 +325,4 @@ function rendersHtml(file) {
 }
 
 //#endregion
-export { adaptFile, changesFor, fileEntries, findRootLayout, isOlderVersion, minCliError, patchEntries, readManifest, resolveDependencies, resolvePatch };
+export { adaptFile, changesFor, fileEntries, findRootLayout, isOlderVersion, minCliError, patchEntries, readManifest, renderNote, resolveDependencies, resolvePatch };

package/dist/index.d.ts

@@ -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, 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

@@ -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, 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 };

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

@@ -0,0 +1,64 @@
+import { IconDescriptor } from "../../brand/icons.js";
+import { S2SClient } from "../../kizlo.js";
+import { SeoHead } from "../../seo/schema.js";
+import { renderJsonLd } from "../../seo/utils.js";
+
+//#region src/integrations/astro/metadata.d.ts
+/** A `<meta name="theme-color">` entry, optionally scoped to a `prefers-color-scheme` media query. */
+interface ThemeColor {
+  media?: string;
+  color: string;
+}
+/**
+ * Brand + site data for the document `<head>`, resolved from WordPress settings. The `.astro`
+ * head component maps this to `<title>`/`<link>`/`<meta>` tags (Astro has no `generateMetadata`,
+ * and this package can't compile `.astro`, so the rendering lives in the template).
+ */
+interface RootHead {
+  /** Web manifest route to link with `rel="manifest"`. */
+  manifest: string;
+  icons: {
+    icon: IconDescriptor[];
+    appleTouch: IconDescriptor[];
+  };
+  /** Site origin used to resolve relative URLs, when set in WordPress. */
+  metadataBase?: string;
+  /** Browser-chrome theme color(s); a light/dark pair carries `prefers-color-scheme` media queries. */
+  themeColor: ThemeColor[];
+}
+/** Per-page SEO tags, mapped from a post's SEO head. Consumed by the template's head component. */
+interface PageHead {
+  title: string;
+  description?: string;
+  canonical: string;
+  robots: string;
+  og: {
+    type: string;
+    title: string;
+    description?: string;
+    url: string;
+    siteName: string;
+    locale: string;
+    image?: {
+      url: string;
+      width?: number;
+      height?: number;
+      alt?: string;
+    };
+  };
+  twitter: {
+    card: string;
+    title: string;
+    description?: string;
+    site?: string;
+    creator?: string;
+    image?: string;
+    imageAlt?: string;
+  };
+}
+/** Resolve the root brand/site head from WordPress settings (icons, manifest, theme color, base URL). */
+declare function resolveRootHead(client: S2SClient<[]>): Promise<RootHead>;
+/** Map a post's SEO head to the flat descriptors the template's head component renders. */
+declare function resolvePageHead(head: SeoHead): PageHead;
+//#endregion
+export { PageHead, RootHead, ThemeColor, resolvePageHead, resolveRootHead };