kizlo 0.20.2 → 0.22.0

package/dist/page/index.js

@@ -24,7 +24,7 @@ const PAGE_PROCEDURES = {
 		if (input.query?.previewToken) {
 			const result = await context.verifyPreviewToken(input.query.previewToken);
 			if (!result) throw errors.PAGE_NOT_FOUND();
-			const response$1 = await context.wordpress.postTypes.page.retrieve({ identifier: String(result.id) });
+			const response$1 = await context.wordpress.kizlo.postTypes.page.retrieve({ params: { identifier: String(result.id) } });
 			if (response$1.error) switch (response$1.error.code) {
 				case "invalid_post_type":
 				case "post_type_not_found":
@@ -44,7 +44,7 @@ const PAGE_PROCEDURES = {
 		}
 		const identifier = parseIdentifier(input.params.identifier);
 		if (!identifier) throw errors.PAGE_NOT_FOUND();
-		const response = await context.wordpress.postTypes.page.retrieve({ identifier: String(identifier.value) });
+		const response = await context.wordpress.kizlo.postTypes.page.retrieve({ params: { identifier: String(identifier.value) } });
 		if (response.error) switch (response.error.code) {
 			case "invalid_post_type":
 			case "post_type_not_found":
@@ -78,7 +78,7 @@ const PAGE_PROCEDURES = {
 	}, async ({ input, context, errors }) => {
 		const q = input.query;
 		const orderby = q?.orderby === "relevance" && !q?.search || q?.orderby === "include" && q?.include === void 0 ? void 0 : q?.orderby;
-		const response = await context.wordpress.postTypes.page.list({
+		const response = await context.wordpress.kizlo.postTypes.page.list({ query: {
 			status: ["publish"],
 			after: q?.after,
 			author: normalizeArrayableValue(q?.author),
@@ -99,7 +99,7 @@ const PAGE_PROCEDURES = {
 			search: q?.search,
 			search_columns: q?.searchColumns,
 			slug: normalizeArrayableValue(q?.slug)
-		});
+		} });
 		if (response.error) switch (response.error.code) {
 			case "rest_post_invalid_page_number": throw errors.PAGE_INVALID_PAGE();
 			case "rest_no_route": throw errors.PAGE_NOT_FOUND();

package/dist/page/schema.d.ts

@@ -5,7 +5,7 @@ import z from "zod/v4";
 
 //#region src/page/schema.d.ts
 
-type PageCustomFields = WP_CustomFields<"postTypes.page">;
+type PageCustomFields = WP_CustomFields<"kizlo.postTypes.page">;
 declare const PageCustomFieldsSchema: z.ZodType<PageCustomFields, PageCustomFields>;
 declare const Page: z.ZodObject<{
   id: z.ZodNumber;

package/dist/post/index.js

@@ -24,7 +24,7 @@ const POST_PROCEDURES = {
 		if (input.query?.previewToken) {
 			const result = await context.verifyPreviewToken(input.query.previewToken);
 			if (!result) throw errors.POST_NOT_FOUND();
-			const response$1 = await context.wordpress.postTypes.post.retrieve({ identifier: String(result.id) });
+			const response$1 = await context.wordpress.kizlo.postTypes.post.retrieve({ params: { identifier: String(result.id) } });
 			if (response$1.error) switch (response$1.error.code) {
 				case "invalid_post_type":
 				case "post_type_not_found":
@@ -44,7 +44,7 @@ const POST_PROCEDURES = {
 		}
 		const identifier = parseIdentifier(input.params.identifier);
 		if (!identifier) throw errors.POST_NOT_FOUND();
-		const response = await context.wordpress.postTypes.post.retrieve({ identifier: String(identifier.value) });
+		const response = await context.wordpress.kizlo.postTypes.post.retrieve({ params: { identifier: String(identifier.value) } });
 		if (response.error) switch (response.error.code) {
 			case "invalid_post_type":
 			case "post_type_not_found":
@@ -78,7 +78,7 @@ const POST_PROCEDURES = {
 	}, async ({ input, context, errors }) => {
 		const q = input.query;
 		const orderby = q?.orderby === "relevance" && !q?.search || q?.orderby === "include" && q?.include === void 0 ? void 0 : q?.orderby;
-		const response = await context.wordpress.postTypes.post.list({
+		const response = await context.wordpress.kizlo.postTypes.post.list({ query: {
 			status: ["publish"],
 			after: q?.after,
 			author: normalizeArrayableValue(q?.author),
@@ -102,7 +102,7 @@ const POST_PROCEDURES = {
 			tags: normalizeArrayableValue(q?.tags),
 			tags_exclude: normalizeArrayableValue(q?.tagsExclude),
 			tax_relation: q?.taxRelation
-		});
+		} });
 		if (response.error) switch (response.error.code) {
 			case "rest_post_invalid_page_number": throw errors.POST_INVALID_PAGE();
 			case "rest_no_route": throw errors.POST_NOT_FOUND();

package/dist/post/schema.d.ts

@@ -5,7 +5,7 @@ import z from "zod/v4";
 
 //#region src/post/schema.d.ts
 
-type PostCustomFields = WP_CustomFields<"postTypes.post">;
+type PostCustomFields = WP_CustomFields<"kizlo.postTypes.post">;
 declare const PostCustomFieldsSchema: z.ZodType<PostCustomFields, PostCustomFields>;
 declare const Post: z.ZodObject<{
   id: z.ZodNumber;

package/dist/procedures.d.ts

@@ -44,7 +44,7 @@ declare const CORE_PROCEDURES: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
+        orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         taxRelation?: "AND" | "OR" | undefined;
@@ -99,7 +99,7 @@ declare const CORE_PROCEDURES: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
+        orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         parent?: string | number | (string | number)[] | undefined;
@@ -136,7 +136,7 @@ declare const CORE_PROCEDURES: {
         exclude?: string | number | (string | number)[] | undefined;
         include?: string | number | (string | number)[] | undefined;
         order?: "asc" | "desc" | undefined;
-        orderBy?: "count" | "id" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
+        orderBy?: "id" | "count" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
         hideEmpty?: string | boolean | undefined;
         parent?: string | number | undefined;
         post?: string | number | undefined;
@@ -172,7 +172,7 @@ declare const CORE_PROCEDURES: {
         exclude?: string | number | (string | number)[] | undefined;
         include?: string | number | (string | number)[] | undefined;
         order?: "asc" | "desc" | undefined;
-        orderBy?: "count" | "id" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
+        orderBy?: "id" | "count" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
         hideEmpty?: string | boolean | undefined;
         post?: string | number | undefined;
         slug?: string | string[] | undefined;
@@ -292,7 +292,7 @@ declare const CORE_PROCEDURES: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -371,7 +371,7 @@ declare const CORE_PROCEDURES: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -507,7 +507,7 @@ declare const CORE_PROCEDURES: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "date" | "id" | "parent" | "include" | "post" | undefined;
+        orderby?: "id" | "date" | "parent" | "include" | "post" | undefined;
         parent?: string | number | (string | number)[] | undefined;
         parentExclude?: string | number | (string | number)[] | undefined;
         post?: string | number | (string | number)[] | undefined;

package/dist/seo/index.js

@@ -28,7 +28,7 @@ const SEO_PROCEDURES = {
 		scope: "internal",
 		output: Seo
 	}, async ({ context, errors }) => {
-		const response = await context.wordpress.seo.homepage.retrieve();
+		const response = await context.wordpress.kizlo.seo.homepage.retrieve();
 		if (response.error) {
 			context.logger.error("Get homepage seo unhandled error", response.error);
 			throw errors.INTERNAL_SERVER_ERROR();
@@ -40,7 +40,7 @@ const SEO_PROCEDURES = {
 			scope: "internal",
 			output: SitemapList
 		}, async ({ context, errors }) => {
-			const response = await context.wordpress.seo.sitemaps.list();
+			const response = await context.wordpress.kizlo.seo.sitemaps.list();
 			if (response.error) {
 				context.logger.error("List sitemaps unhandled error", response.error);
 				throw errors.INTERNAL_SERVER_ERROR();
@@ -51,7 +51,7 @@ const SEO_PROCEDURES = {
 			scope: "internal",
 			output: SitemapIndex
 		}, async ({ context, errors }) => {
-			const response = await context.wordpress.seo.sitemaps.retrieve({ type: "index" });
+			const response = await context.wordpress.kizlo.seo.sitemaps.retrieve({ params: { type: "index" } });
 			if (response.error) {
 				context.logger.error("Get sitemap index unhandled error", response.error);
 				throw errors.INTERNAL_SERVER_ERROR();
@@ -70,7 +70,7 @@ const SEO_PROCEDURES = {
 		scope: "internal",
 		output: Robots
 	}, async ({ context, errors }) => {
-		const response = await context.wordpress.seo.robots.retrieve();
+		const response = await context.wordpress.kizlo.seo.robots.retrieve();
 		if (response.error) {
 			context.logger.error("List robots unhandled error", response.error);
 			throw errors.INTERNAL_SERVER_ERROR();
@@ -90,13 +90,15 @@ const SEO_PROCEDURES = {
 		input: ListSitemapUrlInput
 	}, async ({ context, input, errors }) => {
 		const page = input.page ?? 1;
-		const response = input.type === "author" ? await context.wordpress.seo.sitemaps.retrieve({
-			type: "author",
-			page
-		}) : await context.wordpress.seo.sitemaps.listUrls({
-			type: input.type,
-			key: input.key,
-			page
+		const response = input.type === "author" ? await context.wordpress.kizlo.seo.sitemaps.retrieve({
+			params: { type: "author" },
+			query: { page }
+		}) : await context.wordpress.kizlo.seo.sitemaps.listUrls({
+			params: {
+				type: input.type,
+				key: input.key
+			},
+			query: { page }
 		});
 		if (response.error) {
 			context.logger.error("List sitemap urls unhandled error", response.error);

package/dist/seo/types.d.ts

@@ -3,11 +3,11 @@ import "../wordpress/index.js";
 
 //#region src/seo/types.d.ts
 /** The resolved SEO block, exactly as the project's generated WordPress client describes it. */
-type WPK_Seo = WP_EndpointData<"seo.homepage.retrieve">;
-type WPK_Robots = WP_EndpointData<"seo.robots.retrieve">;
+type WPK_Seo = WP_EndpointData<"kizlo.seo.homepage.retrieve">;
+type WPK_Robots = WP_EndpointData<"kizlo.seo.robots.retrieve">;
 type WPK_RobotRule = WPK_Robots["rules"][number];
-type WPK_Sitemap = WP_EndpointData<"seo.sitemaps.list">[number];
-type WPK_SitemapUrl = WP_EndpointData<"seo.sitemaps.listUrls">[number];
+type WPK_Sitemap = WP_EndpointData<"kizlo.seo.sitemaps.list">[number];
+type WPK_SitemapUrl = WP_EndpointData<"kizlo.seo.sitemaps.listUrls">[number];
 type WPK_SitemapUrlImage = WPK_SitemapUrl["images"][number];
 //#endregion
 export { WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapUrl, WPK_SitemapUrlImage };

package/dist/settings/service.d.ts

@@ -7,17 +7,17 @@ declare class SettingsService {
   private readonly wordpress;
   constructor(wordpress: ActiveWordPressClient);
   /** Fetch every Kizlo settings section in one response. */
-  get(): Promise<WP_EndpointResult<"settings.retrieve">>;
-  updateSite(input: SiteSettingsInput): Promise<WP_EndpointResult<"settings.site.update">>;
-  updateBrand(input: BrandSettingsInput): Promise<WP_EndpointResult<"settings.brand.update">>;
-  updateWebhook(input: WebhookSettingsInput): Promise<WP_EndpointResult<"settings.webhook.update">>;
-  updateIdentity(input: IdentitySettingsInput): Promise<WP_EndpointResult<"settings.identity.update">>;
-  updateAuthors(input: AuthorsSettingsInput): Promise<WP_EndpointResult<"settings.authors.update">>;
-  updateCrawling(input: CrawlingSettingsInput): Promise<WP_EndpointResult<"settings.crawling.update">>;
-  updateUploads(input: UploadsSettingsInput): Promise<WP_EndpointResult<"settings.uploads.update">>;
-  updateHeadless(input: HeadlessSettingsInput): Promise<WP_EndpointResult<"settings.headless.update">>;
-  updatePostType(key: string, input: PostTypeSettingsInput): Promise<WP_EndpointResult<"settings.postTypes.update">>;
-  updateTaxonomy(key: string, input: TaxonomySettingsInput): Promise<WP_EndpointResult<"settings.taxonomies.update">>;
+  get(): Promise<WP_EndpointResult<"kizlo.settings.retrieve">>;
+  updateSite(input: SiteSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.site.update">>;
+  updateBrand(input: BrandSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.brand.update">>;
+  updateWebhook(input: WebhookSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.webhook.update">>;
+  updateIdentity(input: IdentitySettingsInput): Promise<WP_EndpointResult<"kizlo.settings.identity.update">>;
+  updateAuthors(input: AuthorsSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.authors.update">>;
+  updateCrawling(input: CrawlingSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.crawling.update">>;
+  updateUploads(input: UploadsSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.uploads.update">>;
+  updateHeadless(input: HeadlessSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.headless.update">>;
+  updatePostType(key: string, input: PostTypeSettingsInput): Promise<WP_EndpointResult<"kizlo.settings.postTypes.update">>;
+  updateTaxonomy(key: string, input: TaxonomySettingsInput): Promise<WP_EndpointResult<"kizlo.settings.taxonomies.update">>;
 }
 //#endregion
 export { SettingsService };

package/dist/settings/service.js

@@ -6,42 +6,42 @@ var SettingsService = class {
 	}
 	/** Fetch every Kizlo settings section in one response. */
 	async get() {
-		return this.wordpress.settings.retrieve();
+		return this.wordpress.kizlo.settings.retrieve();
 	}
 	async updateSite(input) {
-		return this.wordpress.settings.site.update(input);
+		return this.wordpress.kizlo.settings.site.update({ body: input });
 	}
 	async updateBrand(input) {
-		return this.wordpress.settings.brand.update(input);
+		return this.wordpress.kizlo.settings.brand.update({ body: input });
 	}
 	async updateWebhook(input) {
-		return this.wordpress.settings.webhook.update(input);
+		return this.wordpress.kizlo.settings.webhook.update({ body: input });
 	}
 	async updateIdentity(input) {
-		return this.wordpress.settings.identity.update(input);
+		return this.wordpress.kizlo.settings.identity.update({ body: input });
 	}
 	async updateAuthors(input) {
-		return this.wordpress.settings.authors.update(input);
+		return this.wordpress.kizlo.settings.authors.update({ body: input });
 	}
 	async updateCrawling(input) {
-		return this.wordpress.settings.crawling.update(input);
+		return this.wordpress.kizlo.settings.crawling.update({ body: input });
 	}
 	async updateUploads(input) {
-		return this.wordpress.settings.uploads.update(input);
+		return this.wordpress.kizlo.settings.uploads.update({ body: input });
 	}
 	async updateHeadless(input) {
-		return this.wordpress.settings.headless.update(input);
+		return this.wordpress.kizlo.settings.headless.update({ body: input });
 	}
 	async updatePostType(key, input) {
-		return this.wordpress.settings.postTypes.update({
-			...input,
-			slug: key
+		return this.wordpress.kizlo.settings.postTypes.update({
+			params: { slug: key },
+			body: input
 		});
 	}
 	async updateTaxonomy(key, input) {
-		return this.wordpress.settings.taxonomies.update({
-			...input,
-			slug: key
+		return this.wordpress.kizlo.settings.taxonomies.update({
+			params: { slug: key },
+			body: input
 		});
 	}
 };

package/dist/shared/constants.js

@@ -5,6 +5,8 @@ import { milliseconds } from "@kizlo/shared";
 const VERSION = version;
 const RPC_PROTOCOL_HEADER = "x-rpc-protocol";
 const SESSION_EXPIRY_MARGIN_MS = milliseconds("5 minutes");
+/** Mount order for the built-in framework integrations, ahead of app integrations that leave `order` unset. */
+const FRAMEWORK_INTEGRATION_ORDER = -100;
 
 //#endregion
-export { RPC_PROTOCOL_HEADER };
+export { FRAMEWORK_INTEGRATION_ORDER, RPC_PROTOCOL_HEADER };

package/dist/shared/integration.d.ts

@@ -69,11 +69,19 @@ interface Integration<TId extends string, TProcedures extends AnyProcedureTree =
   env?: EnvSource;
   /** Environment, endpoint, and WordPress plugin requirements checked at their documented lifecycle points. */
   requires?: IntegrationRequirements;
+  /**
+   * Mount position, ascending, defaulting to `0`. Mounting first means supplying the baseline a later
+   * integration overrides, so a framework integration declares a negative order to land ahead of app
+   * integrations however the `integrations` array is written.
+   */
+  order?: number;
 }
 type AnyIntegration = Integration<any, AnyProcedureTree>;
 type ExtractIntegrationProcedures<TIntegration extends AnyIntegration> = TIntegration extends Integration<infer Name, infer Procedures> ? [keyof Procedures] extends [never] ? never : string extends keyof Procedures ? never : Record<Name, Procedures> : never;
 type InferIntegrationProcedures<TIntegrations extends readonly AnyIntegration[]> = TIntegrations extends readonly [] ? Record<never, never> : ExtractIntegrationProcedures<TIntegrations[number]> extends infer R ? [R] extends [never] ? Record<never, never> : UnionToIntersection<R> : never;
 declare function createIntegration<TId extends string, TProcedures extends AnyProcedureTree = Record<never, never>>(integration: Integration<TId, TProcedures>): Integration<TId, TProcedures>;
+/** Integrations in mount order. `sort` is stable, so integrations sharing an `order` keep their declared order. */
+declare function sortIntegrations<TIntegration extends AnyIntegration>(integrations: readonly TIntegration[]): TIntegration[];
 /** The declared subtrees the generated tree does not have. */
 declare function missingEndpoints(endpoints: object, required: readonly string[]): string[];
 /**
@@ -88,4 +96,4 @@ declare function assertIntegrationEndpoints(integration: AnyIntegration, endpoin
 /** Fail at startup when an integration's required environment values are absent. */
 declare function assertIntegrationEnv(integration: AnyIntegration, env: EnvSource): void;
 //#endregion
-export { AnyIntegration, EnvReader, EnvRecord, EnvSource, ExtractIntegrationProcedures, InferIntegrationProcedures, Integration, IntegrationRequirements, KizloEnv, WordPressEnv, assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv };
+export { AnyIntegration, EnvReader, EnvRecord, EnvSource, ExtractIntegrationProcedures, InferIntegrationProcedures, Integration, IntegrationRequirements, KizloEnv, WordPressEnv, assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv, sortIntegrations };

package/dist/shared/integration.js

@@ -18,6 +18,10 @@ function missingEnv(source, required) {
 function createIntegration(integration) {
 	return integration;
 }
+/** Integrations in mount order. `sort` is stable, so integrations sharing an `order` keep their declared order. */
+function sortIntegrations(integrations) {
+	return [...integrations].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
 /** The declared subtrees the generated tree does not have. */
 function missingEndpoints(endpoints, required) {
 	return required.filter((path) => {
@@ -43,8 +47,7 @@ function assertIntegrationEndpoints(integration, endpoints) {
 	const missing = missingEndpoints(endpoints, required);
 	if (missing.length === 0) return;
 	const plugins = integration.requires?.plugins;
-	const remedy = plugins?.length ? `Install or update the required WordPress plugins (${plugins.map((plugin) => `${plugin.name} ${plugin.version}+`).join(", ")}), then run \`kizlo generate\`.` : "Run `kizlo generate` against a WordPress that serves them.";
-	throw new KizloError("MISSING_WORDPRESS_ENDPOINTS", { message: `The "${integration.id}" integration needs WordPress endpoints your generated client does not have: ${missing.join(", ")}. ${remedy}` });
+	throw new KizloError("MISSING_WORDPRESS_ENDPOINTS", { message: `${plugins?.length ? `The "${integration.id}" integration plugin is outdated. Update ${plugins.map((plugin) => `${plugin.name} to ${plugin.version} or newer`).join(" and ")}, then run \`kizlo generate\` to refresh introspection.ts.` : `The "${integration.id}" integration is missing routes in your introspection. Run \`kizlo generate\` against a WordPress that serves them to refresh introspection.ts.`}\n\nMissing routes:\n${missing.map((route) => `  - ${route}`).join("\n")}\n\n${`Download the latest version: https://kizlo.io/integrations/${integration.id}`}` });
 }
 /** Fail at startup when an integration's required environment values are absent. */
 function assertIntegrationEnv(integration, env) {
@@ -56,4 +59,4 @@ function assertIntegrationEnv(integration, env) {
 }
 
 //#endregion
-export { assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv };
+export { assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv, sortIntegrations };

package/dist/tag/index.js

@@ -18,7 +18,7 @@ const TAG_PROCEDURES = {
 	}, async ({ input, context, errors }) => {
 		const identifier = parseIdentifier(input.params.identifier);
 		if (!identifier) throw errors.TAG_NOT_FOUND();
-		const response = await context.wordpress.taxonomies.postTag.retrieve({ identifier: String(identifier.value) });
+		const response = await context.wordpress.kizlo.taxonomies.postTag.retrieve({ params: { identifier: String(identifier.value) } });
 		if (response.error) switch (response.error.code) {
 			case "invalid_taxonomy":
 			case "term_not_found":
@@ -41,7 +41,7 @@ const TAG_PROCEDURES = {
 		output: schemaType(TagList),
 		errors: LIST_TAG_ERROR_MAP
 	}, async ({ input, context, errors }) => {
-		const response = await context.wordpress.taxonomies.postTag.list({
+		const response = await context.wordpress.kizlo.taxonomies.postTag.list({ query: {
 			page: input.query?.page,
 			per_page: input.query?.perPage,
 			search: input.query?.search,
@@ -52,7 +52,7 @@ const TAG_PROCEDURES = {
 			hide_empty: input.query?.hideEmpty,
 			post: input.query?.post,
 			slug: normalizeArrayableValue(input.query?.slug)
-		});
+		} });
 		if (response.error) switch (response.error.code) {
 			case "rest_post_invalid_page_number": throw errors.TAG_INVALID_PAGE();
 			case "rest_no_route": throw errors.TAG_NOT_FOUND();

package/dist/tag/schema.d.ts

@@ -4,7 +4,7 @@ import * as _kizlo_shared24 from "@kizlo/shared";
 import z from "zod/v4";
 
 //#region src/tag/schema.d.ts
-type TagCustomFields = WP_CustomFields<"taxonomies.postTag">;
+type TagCustomFields = WP_CustomFields<"kizlo.taxonomies.postTag">;
 declare const TagCustomFieldsSchema: z.ZodType<TagCustomFields, TagCustomFields>;
 declare const Tag: z.ZodObject<{
   id: z.ZodNumber;

package/dist/wordpress/endpoint.d.ts

@@ -1,4 +1,4 @@
-import { WP_Client, WP_Endpoint, WP_EndpointDefinition, WP_RequestBuild } from "./types.js";
+import { WP_Client, WP_Endpoint, WP_EndpointDefinition, WP_RequestBuild, WP_RequestParts } from "./types.js";
 import { WordPressTransport } from "./transport.js";
 
 //#region src/wordpress/endpoint.d.ts
@@ -10,14 +10,24 @@ import { WordPressTransport } from "./transport.js";
  */
 declare function wpEndpoint<TInput, TResult>(definition: WP_EndpointDefinition): WP_Endpoint<TInput, TResult>;
 /**
- * Turn a definition and its input into a request: interpolate path parameters, then split the rest.
+ * Turn a definition and its input into a request: interpolate `params` into the path, put `query` on
+ * the URL, and forward `body` as it stands.
+ *
+ * Each part goes exactly where the caller put it, so nothing has to be inferred from the input's own
+ * keys. That matters because a field can legitimately be named `body` — `kizlo.email.send` takes one
+ * — and it is what lets a body method also carry query parameters, which the old method-based split
+ * could not express.
+ *
+ * Whether the request has a body at all is the definition's to answer: `requestContentType` is set
+ * for exactly those operations that declare one. A declared body left unsupplied is sent as an empty
+ * object rather than dropped, which is the shape a call with no fields has always sent.
  *
  * A path parameter that cannot be interpolated comes back as an error rather than throwing. The
  * generated input marks these required, so TypeScript catches the ones it can see, and what reaches
  * here is the value that was present but unusable — typically an identifier read off a request the
  * caller never validated.
  */
-declare function buildWordPressRequest(definition: WP_EndpointDefinition, input: object): WP_RequestBuild;
+declare function buildWordPressRequest(definition: WP_EndpointDefinition, input: WP_RequestParts): WP_RequestBuild;
 declare function createWordPressClient<TEndpoints extends object>(transport: WordPressTransport, endpoints: TEndpoints): WP_Client<TEndpoints> & WordPressTransport;
 //#endregion
 export { buildWordPressRequest, createWordPressClient, wpEndpoint };

package/dist/wordpress/endpoint.js

@@ -28,7 +28,17 @@ function describeValue(value) {
 	return typeof value;
 }
 /**
-* Turn a definition and its input into a request: interpolate path parameters, then split the rest.
+* Turn a definition and its input into a request: interpolate `params` into the path, put `query` on
+* the URL, and forward `body` as it stands.
+*
+* Each part goes exactly where the caller put it, so nothing has to be inferred from the input's own
+* keys. That matters because a field can legitimately be named `body` — `kizlo.email.send` takes one
+* — and it is what lets a body method also carry query parameters, which the old method-based split
+* could not express.
+*
+* Whether the request has a body at all is the definition's to answer: `requestContentType` is set
+* for exactly those operations that declare one. A declared body left unsupplied is sent as an empty
+* object rather than dropped, which is the shape a call with no fields has always sent.
 *
 * A path parameter that cannot be interpolated comes back as an error rather than throwing. The
 * generated input marks these required, so TypeScript catches the ones it can see, and what reaches
@@ -37,9 +47,9 @@ function describeValue(value) {
 */
 function buildWordPressRequest(definition, input) {
 	let path = definition.path;
-	const rest = { ...input };
+	const params = input.params ?? {};
 	for (const name of definition.pathParameters) {
-		const value = rest[name];
+		const value = params[name];
 		if (!isUsablePathParameter(value)) return {
 			request: null,
 			error: new WP_Error({
@@ -50,22 +60,18 @@ function buildWordPressRequest(definition, input) {
 		const encoded = encodeURIComponent(String(value));
 		const marker = `{${name}}`;
 		while (path.includes(marker)) path = path.replace(marker, encoded);
-		delete rest[name];
 	}
-	const hasBody = [
-		"POST",
-		"PUT",
-		"PATCH"
-	].includes(definition.method);
+	const hasBody = definition.requestContentType !== void 0;
 	return {
 		request: {
 			base: `/wp-json/${definition.namespace}`,
 			path,
 			method: definition.method,
 			...hasBody ? {
-				body: rest,
+				body: input.body ?? {},
 				requestContentType: definition.requestContentType
-			} : { searchParams: rest },
+			} : {},
+			...input.query ? { searchParams: input.query } : {},
 			responseContentTypes: definition.responseContentTypes,
 			dataResponseStatuses: definition.dataResponseStatuses
 		},
@@ -91,9 +97,15 @@ function createCaller(definition, transport) {
 			headers: new Headers(),
 			error: built.error
 		};
+		const { searchParams,...rest } = options ?? {};
+		const query = searchParams ? {
+			...built.request.searchParams,
+			...searchParams
+		} : built.request.searchParams;
 		return transport.request({
 			...built.request,
-			...options
+			...rest,
+			...query ? { searchParams: query } : {}
 		});
 	};
 }

package/dist/wordpress/generate.js

@@ -215,10 +215,51 @@ function renderResult(apiId, operationId, operation, context) {
 * described.
 */
 const NO_INPUT = "Record<string, never>";
+/**
+* Whether anything inside an object schema has to be supplied, following `$extends` the way
+* {@link inheritedPropertyTypes} does, since an inherited property is as required as an own one.
+*/
+function hasRequiredMember(schema, context, seen = /* @__PURE__ */ new Set()) {
+	if (Object.values(schema.properties ?? {}).some((child) => child.required)) return true;
+	const parents = schema.$extends ? Array.isArray(schema.$extends) ? schema.$extends : [schema.$extends] : [];
+	for (const parent of parents) {
+		if (seen.has(parent)) continue;
+		seen.add(parent);
+		const parentSchema = context.schemas.get(parent);
+		if (parentSchema && hasRequiredMember(parentSchema, context, seen)) return true;
+	}
+	return false;
+}
+/**
+* Whether a part must be passed. An object part is demanded only when something in it is required,
+* so a list's `query` stays optional and a retrieve's `params` does not. Anything else — an array
+* body, a scalar body — is the value itself rather than a container of fields, and has no way to be
+* half-supplied, so passing it is the only way to send one.
+*/
+function isRequiredPart(schema, context) {
+	return schema.type === "object" ? hasRequiredMember(schema, context) : schema.required !== false;
+}
+/**
+* The parts an operation takes, each rendered under its own key. A part the operation does not
+* declare is absent, and one whose contents are undescribed is dropped rather than rendered as an
+* open record: an operation left with no part at all takes nothing, which is what {@link NO_INPUT}
+* says.
+*/
 function renderInput(apiId, operationId, operation, context) {
 	const name = endpointName(apiId, operationId, "EndpointInput");
-	const input = renderType(operation.input, context);
-	const declaration = input === UNDESCRIBED_OBJECT ? NO_INPUT : input;
+	const members = [];
+	for (const part of [
+		"params",
+		"query",
+		"body"
+	]) {
+		const schema = operation.input[part];
+		if (!schema) continue;
+		const rendered = renderType(schema, context, "	");
+		if (rendered === UNDESCRIBED_OBJECT) continue;
+		members.push(`\t${part}${isRequiredPart(schema, context) ? "" : "?"}: ${rendered}`);
+	}
+	const declaration = members.length === 0 ? NO_INPUT : `{\n${members.join("\n")}\n}`;
 	return `${jsdoc(operation.description ?? operation.summary, operation.deprecated)}export type ${name} = ${declaration}`;
 }
 function endpointTree(document) {
@@ -257,8 +298,13 @@ function sortedChildren(node) {
 function sortedEndpoints(node) {
 	return [...node.endpoints].sort((left, right) => left.member.localeCompare(right.member));
 }
+/**
+* The runtime descriptor for one operation: what the generated client emits, and what anything calling
+* a route straight off the introspection document needs to build its request. Exported because the
+* CLI's MCP server dispatches routes the client never generated a member for.
+*/
 function endpointDefinition(entry) {
-	const pathParameters = sortedEntries(entry.operation.input.properties ?? {}).filter(([, schema]) => schema.in === "path").map(([name]) => name);
+	const pathParameters = sortedEntries(entry.operation.input.params?.properties ?? {}).map(([name]) => name);
 	const responseContentTypes = Object.fromEntries(sortedEntries(entry.operation.responses).map(([status, response]) => [status, response.content_type]));
 	const dataResponseStatuses = sortedEntries(entry.operation.responses).filter(([status, response]) => !isSuccessStatus(status) && !isWordPressErrorResponse(response)).map(([status]) => status);
 	return {
@@ -266,7 +312,7 @@ function endpointDefinition(entry) {
 		path: entry.path,
 		method: entry.operation.method,
 		pathParameters,
-		...entry.operation.input.content_type ? { requestContentType: entry.operation.input.content_type } : {},
+		...entry.operation.input.body?.content_type ? { requestContentType: entry.operation.input.body.content_type } : {},
 		responseContentTypes,
 		...dataResponseStatuses.length > 0 ? { dataResponseStatuses } : {}
 	};
@@ -319,12 +365,14 @@ function renderEndpointRegistry(node, path = []) {
 function renderCustomFieldsRegistry(document) {
 	const entries = [];
 	for (const id of Object.keys(document.schemas).sort((left, right) => left.localeCompare(right))) {
-		const match = /^(post-types|taxonomies)\.([^.]+)\.item$/.exec(id);
+		const match = /^((?:[^.]+\.)*)(post-types|taxonomies)\.([^.]+)\.item$/.exec(id);
 		if (!match) continue;
-		const namespace = match[1] === "post-types" ? "postTypes" : "taxonomies";
-		const slug = match[2];
+		if (!document.schemas[id]?.properties?.kizlo?.properties?.custom) continue;
+		const prefix = (match[1] ?? "").split(".").filter(Boolean).map((segment) => `${camel(segment)}.`).join("");
+		const namespace = match[2] === "post-types" ? "postTypes" : "taxonomies";
+		const slug = match[3];
 		if (!slug) continue;
-		entries.push(`\t\t${JSON.stringify(`${namespace}.${camel(slug)}`)}: ${schemaName(id)}["kizlo"]["custom"]`);
+		entries.push(`\t\t${JSON.stringify(`${prefix}${namespace}.${camel(slug)}`)}: ${schemaName(id)}["kizlo"]["custom"]`);
 	}
 	return entries;
 }
@@ -454,4 +502,4 @@ function generateWordPressModule(document) {
 }
 
 //#endregion
-export { generateWordPressModule };
+export { camel, endpointDefinition, generateWordPressModule };