kizlo 0.17.0 → 0.18.0

package/dist/seo/index.js

@@ -1,5 +1,5 @@
-import { createProcedure } from "../shared/procedure.js";
 import { ListSitemapUrlInput, Robots, Seo, SitemapIndex, SitemapList, SitemapUrlList } from "./schema.js";
+import { createProcedure } from "../shared/procedure.js";
 import { deserializeSeo } from "./utils.js";
 
 //#region src/seo/index.ts

package/dist/seo/schema.d.ts

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

package/dist/shared/contract.d.ts

@@ -1,7 +1,7 @@
 import { HTTPMethod } from "./types.js";
 import { AnyProcedureTree, InvocationScope } from "./procedure.js";
-import { AnyContractRouter } from "@orpc/contract";
 import { Pathname } from "@kizlo/shared";
+import { AnyContractRouter } from "@orpc/contract";
 
 //#region src/shared/contract.d.ts
 type Contract = {

package/dist/shared/procedure.d.ts

@@ -1,13 +1,18 @@
 import { ProcedureContext } from "../context.js";
 import { DefinedErrorMapLike, ThrowableErrorMap, WithCommonErrorMap } from "./error.js";
 import { AnyMiddleware, InferMiddlewares, Middleware } from "./middleware.js";
-import * as _orpc_contract0 from "@orpc/contract";
 import { DeepMerge, Pathname, Prettify, Promisify, Schema, SchemaInput, SchemaOutput } from "@kizlo/shared";
+import * as _orpc_contract0 from "@orpc/contract";
 import * as _orpc_server0 from "@orpc/server";
 import { HTTPMethod } from "@orpc/server";
 import { JsonifiedValue } from "@orpc/openapi-client";
 
 //#region src/shared/procedure.d.ts
+declare const schemaTypeOutput: unique symbol;
+type TypedSchema<TInput, TOutput = TInput> = Schema<TInput, TOutput> & {
+  readonly [schemaTypeOutput]: TOutput;
+};
+type ProcedureOutput<TScope, TOutput extends Schema> = TScope extends "api" ? TOutput extends TypedSchema<any, infer TPreservedOutput> ? TPreservedOutput : JsonifiedValue<SchemaOutput<TOutput>> : SchemaOutput<TOutput>;
 type AnyProcedureTree = {
   [K: string]: AnyProcedure | AnyProcedureTree;
 };
@@ -110,8 +115,12 @@ type ProcedureOptions<TScope extends InvocationScope, TPathname extends Pathname
   /** Schema for the call's single input argument. */
   input?: TInput;
 });
-declare function createProcedure<TScope extends InvocationScope, TPathname extends Pathname, TInput extends Schema | undefined = undefined, TBody extends Schema | undefined = undefined, TParams extends Schema | undefined = undefined, TQuery extends Schema | undefined = undefined, THeaders extends Schema | undefined = undefined, TOutput extends Schema = Schema, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TMiddlewares extends Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[] = Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[], TContext extends ProcedureContext & InferMiddlewares<TMiddlewares> = ProcedureContext & InferMiddlewares<TMiddlewares>>(options: ProcedureOptions<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders, TOutput, TError, TMiddlewares>, handler: ProcedureHandler<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError, TContext>): Procedure<TScope, ResolvedSchemaInput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, TScope extends "api" ? JsonifiedValue<SchemaOutput<TOutput>> : SchemaOutput<TOutput>, TError>;
-declare function schemaType<TInput, TOutput = TInput>(schema?: Schema): Schema<TInput, TOutput>;
+declare function createProcedure<TScope extends InvocationScope, TPathname extends Pathname, TInput extends Schema | undefined = undefined, TBody extends Schema | undefined = undefined, TParams extends Schema | undefined = undefined, TQuery extends Schema | undefined = undefined, THeaders extends Schema | undefined = undefined, TOutput extends Schema = Schema, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TMiddlewares extends Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[] = Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[], TContext extends ProcedureContext & InferMiddlewares<TMiddlewares> = ProcedureContext & InferMiddlewares<TMiddlewares>>(options: ProcedureOptions<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders, TOutput, TError, TMiddlewares>, handler: ProcedureHandler<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError, TContext>): Procedure<TScope, ResolvedSchemaInput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, ProcedureOutput<TScope, TOutput>, TError>;
+/**
+ * Give a schema an explicit input and output type. For API procedure outputs, the declared output
+ * is already the client-visible wire type and is preserved without structural JSON remapping.
+ */
+declare function schemaType<TInput, TOutput = TInput>(schema?: Schema): TypedSchema<TInput, TOutput>;
 declare function buildProcedure(procedure: AnyProcedure): _orpc_server0.DecoratedProcedure<_orpc_server0.Context & Record<never, never>, _orpc_server0.Context, _orpc_contract0.Schema<unknown, unknown>, _orpc_contract0.Schema<any, any>, Record<never, never>, Record<never, never>>;
 declare function handleUnexpectedError(error: unknown, errors?: DefinedErrorMapLike): never;
 declare function combineDetailed(parts: Record<string, Schema>): Schema;

package/dist/shared/procedure.js

@@ -9,6 +9,10 @@ function createProcedure(options, handler) {
 		handler: (ctx) => handler(ctx)
 	} };
 }
+/**
+* Give a schema an explicit input and output type. For API procedure outputs, the declared output
+* is already the client-visible wire type and is preserved without structural JSON remapping.
+*/
 function schemaType(schema) {
 	return schema ?? { "~standard": {
 		vendor: "custom",

package/dist/shared/result.d.ts

@@ -1,7 +1,7 @@
 import { DefinedErrorMapLike, KizloError, WithCommonErrorMap } from "./error.js";
-import { AnyProcedureTree, Procedure } from "./procedure.js";
-import { NestedClient } from "@orpc/client";
+import { AnyProcedure, AnyProcedureTree, Procedure } from "./procedure.js";
 import { SchemaOutput } from "@kizlo/shared";
+import { NestedClient } from "@orpc/client";
 
 //#region src/shared/result.d.ts
 type MaybeCallerOptions<UInput> = unknown extends UInput ? [] : [UInput] extends [undefined] ? [] : object extends UInput ? [input?: UInput] : [input: UInput];
@@ -9,16 +9,25 @@ type ProcedureMethod<UInput, UOutput, TError extends DefinedErrorMapLike> = {
   (...rest: MaybeCallerOptions<UInput>): Promise<KizloResult<UOutput, TError>>;
   call: (...rest: MaybeCallerOptions<UInput>) => Promise<UOutput>;
 };
-type KizloErrorUnion<TErrors extends DefinedErrorMapLike> = { [K in Extract<keyof TErrors, string>]: KizloError<K, SchemaOutput<TErrors[K]["data"]>> }[Extract<keyof TErrors, string>];
-type KizloResult<TOutput, TErrors extends DefinedErrorMapLike = DefinedErrorMapLike> = {
-  data: TOutput;
+type KizloErrorUnion<TErrors$1 extends DefinedErrorMapLike> = { [K in Extract<keyof TErrors$1, string>]: KizloError<K, SchemaOutput<TErrors$1[K]["data"]>> }[Extract<keyof TErrors$1, string>];
+type KizloResult<TOutput$1, TErrors$1 extends DefinedErrorMapLike = DefinedErrorMapLike> = {
+  data: TOutput$1;
   error: null;
   success: true;
 } | {
   data: undefined;
-  error: KizloErrorUnion<WithCommonErrorMap<TErrors>>;
+  error: KizloErrorUnion<WithCommonErrorMap<TErrors$1>>;
   success: false;
 };
+/** The input accepted by one public Kizlo procedure object. */
+type InferProcedureInput<TProcedure extends AnyProcedure> = TProcedure extends Procedure<any, infer TInput, any, any> ? TInput : never;
+/** The successful data returned by one public Kizlo procedure object. */
+type InferProcedureData<TProcedure extends AnyProcedure> = TProcedure extends Procedure<any, any, infer TOutput, any> ? TOutput : never;
+/** The declared and common client-visible errors returned by one public Kizlo procedure object. */
+type InferProcedureError<TProcedure extends AnyProcedure> = TProcedure extends Procedure<any, any, any, infer TErrors> ? KizloErrorUnion<WithCommonErrorMap<TErrors>> : never;
+/** The complete wrapped result returned by a normal call to one public Kizlo procedure object. */
+type InferProcedureResult<TProcedure extends AnyProcedure> = TProcedure extends Procedure<any, any, infer TOutput, infer TErrors> ? KizloResult<TOutput, TErrors> : never;
 type ResultClient<T extends AnyProcedureTree> = { [K in keyof T]: T[K] extends Procedure<infer _Scope, infer Input, infer Output, infer Errors> ? ProcedureMethod<Input, Output, Errors> : T[K] extends AnyProcedureTree ? ResultClient<T[K]> : never };
+declare function createResultClient<T extends AnyProcedureTree>(client: NestedClient<any>): ResultClient<T>;
 //#endregion
-export { ResultClient };
+export { InferProcedureData, InferProcedureError, InferProcedureInput, InferProcedureResult, KizloErrorUnion, KizloResult, MaybeCallerOptions, ProcedureMethod, ResultClient, createResultClient };

package/dist/shared/types.d.ts

@@ -1,6 +1,6 @@
 import { ListMetadata } from "./schema.js";
-import { NestedClient } from "@orpc/client";
 import { CookieOptions, CookieWithOptions } from "@kizlo/shared";
+import { NestedClient } from "@orpc/client";
 
 //#region src/shared/types.d.ts
 type AnyContext = Record<PropertyKey, any>;

package/dist/tag/index.js

@@ -1,4 +1,4 @@
-import { createProcedure } from "../shared/procedure.js";
+import { createProcedure, schemaType } from "../shared/procedure.js";
 import { parseIdentifier } from "../shared/identifier.js";
 import { deserializeListMetadata } from "../shared/serialize.js";
 import { GET_TAG_ERROR_MAP, LIST_TAG_ERROR_MAP } from "./error.js";
@@ -13,7 +13,7 @@ const TAG_PROCEDURES = {
 		method: "GET",
 		path: "/tags/{identifier}",
 		params: RetrieveTagInput.pick({ identifier: true }),
-		output: Tag,
+		output: schemaType(Tag),
 		errors: GET_TAG_ERROR_MAP
 	}, async ({ input, context, errors }) => {
 		const identifier = parseIdentifier(input.params.identifier);
@@ -38,7 +38,7 @@ const TAG_PROCEDURES = {
 		method: "GET",
 		path: "/tags",
 		query: ListTagInput.optional(),
-		output: TagList,
+		output: schemaType(TagList),
 		errors: LIST_TAG_ERROR_MAP
 	}, async ({ input, context, errors }) => {
 		const response = await context.wordpress.taxonomies.postTag.list({

package/dist/tag/schema.d.ts

@@ -0,0 +1,151 @@
+import { WP_CustomFields } from "../wordpress/types.js";
+import "../wordpress/index.js";
+import * as _kizlo_shared24 from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/tag/schema.d.ts
+type TagCustomFields = WP_CustomFields<"taxonomies.postTag">;
+declare const TagCustomFieldsSchema: z.ZodType<TagCustomFields, TagCustomFields>;
+declare const Tag: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  slug: z.ZodString;
+  url: z.ZodNullable<z.ZodString>;
+  description: z.ZodNullable<z.ZodString>;
+  postCount: z.ZodNumber;
+  seo: z.ZodNullable<z.ZodObject<{
+    head: z.ZodObject<{
+      title: z.ZodString;
+      canonical: z.ZodString;
+      robots: z.ZodObject<{
+        index: z.ZodString;
+        follow: z.ZodString;
+        maxSnippet: z.ZodString;
+        maxImagePreview: z.ZodString;
+        maxVideoPreview: z.ZodString;
+      }, z.core.$strip>;
+      og: z.ZodObject<{
+        locale: z.ZodString;
+        type: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodString;
+        siteName: z.ZodString;
+        description: z.ZodString;
+        image: z.ZodNullable<z.ZodObject<{
+          url: z.ZodString;
+          width: z.ZodNullable<z.ZodNumber>;
+          height: z.ZodNullable<z.ZodNumber>;
+          type: z.ZodNullable<z.ZodString>;
+          alt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      twitter: z.ZodObject<{
+        card: z.ZodEnum<{
+          summary: "summary";
+          summary_large_image: "summary_large_image";
+        }>;
+        title: z.ZodString;
+        site: z.ZodNullable<z.ZodString>;
+        creator: z.ZodNullable<z.ZodString>;
+        description: z.ZodString;
+        image: z.ZodNullable<z.ZodString>;
+        imageAlt: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>;
+      article: z.ZodNullable<z.ZodObject<{
+        publishedTime: z.ZodString;
+        modifiedTime: z.ZodString;
+        author: z.ZodString;
+        authorUrl: z.ZodString;
+        section: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    schema: z.ZodObject<{
+      "@context": z.ZodLiteral<"https://schema.org">;
+      "@graph": z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  custom: z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>;
+  meta: z.ZodRecord<z.ZodString, z.ZodType<_kizlo_shared24.JSONValue, unknown, z.core.$ZodTypeInternals<_kizlo_shared24.JSONValue, unknown>>>;
+}, z.core.$strip>;
+type Tag = Omit<z.output<typeof Tag>, "custom"> & {
+  custom: TagCustomFields;
+};
+declare const TagList: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    slug: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    postCount: z.ZodNumber;
+    seo: z.ZodNullable<z.ZodObject<{
+      head: z.ZodObject<{
+        title: z.ZodString;
+        canonical: z.ZodString;
+        robots: z.ZodObject<{
+          index: z.ZodString;
+          follow: z.ZodString;
+          maxSnippet: z.ZodString;
+          maxImagePreview: z.ZodString;
+          maxVideoPreview: z.ZodString;
+        }, z.core.$strip>;
+        og: z.ZodObject<{
+          locale: z.ZodString;
+          type: z.ZodString;
+          title: z.ZodString;
+          url: z.ZodString;
+          siteName: z.ZodString;
+          description: z.ZodString;
+          image: z.ZodNullable<z.ZodObject<{
+            url: z.ZodString;
+            width: z.ZodNullable<z.ZodNumber>;
+            height: z.ZodNullable<z.ZodNumber>;
+            type: z.ZodNullable<z.ZodString>;
+            alt: z.ZodNullable<z.ZodString>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+        twitter: z.ZodObject<{
+          card: z.ZodEnum<{
+            summary: "summary";
+            summary_large_image: "summary_large_image";
+          }>;
+          title: z.ZodString;
+          site: z.ZodNullable<z.ZodString>;
+          creator: z.ZodNullable<z.ZodString>;
+          description: z.ZodString;
+          image: z.ZodNullable<z.ZodString>;
+          imageAlt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        article: z.ZodNullable<z.ZodObject<{
+          publishedTime: z.ZodString;
+          modifiedTime: z.ZodString;
+          author: z.ZodString;
+          authorUrl: z.ZodString;
+          section: z.ZodString;
+          tags: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      schema: z.ZodObject<{
+        "@context": z.ZodLiteral<"https://schema.org">;
+        "@graph": z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    custom: z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>;
+    meta: z.ZodRecord<z.ZodString, z.ZodType<_kizlo_shared24.JSONValue, unknown, z.core.$ZodTypeInternals<_kizlo_shared24.JSONValue, unknown>>>;
+  }, z.core.$strip>>;
+  meta: z.ZodObject<{
+    page: z.ZodNumber;
+    totalItems: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    nextPage: z.ZodNullable<z.ZodNumber>;
+    prevPage: z.ZodNullable<z.ZodNumber>;
+    hasNextPage: z.ZodBoolean;
+    hasPrevPage: z.ZodBoolean;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type TagList = Omit<z.output<typeof TagList>, "items"> & {
+  items: Tag[];
+};
+//#endregion
+export { Tag, TagCustomFields, TagCustomFieldsSchema, TagList };

package/dist/tag/schema.js

@@ -1,5 +1,5 @@
-import { IdentifierInput, ListMetadata, ListOrder, customFieldsSchema } from "../shared/schema.js";
 import { Seo } from "../seo/schema.js";
+import { IdentifierInput, ListMetadata, ListOrder, customFieldsSchema } from "../shared/schema.js";
 import { BooleanLike, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
 import z from "zod/v4";
 
@@ -14,6 +14,7 @@ const WP_TAG_ORDER_BYS = [
 	"description",
 	"count"
 ];
+const TagCustomFieldsSchema = customFieldsSchema();
 const Tag = z.object({
 	id: z.number(),
 	name: z.string(),
@@ -22,7 +23,7 @@ const Tag = z.object({
 	description: z.string().nullable(),
 	postCount: z.number(),
 	seo: Seo.nullable(),
-	custom: customFieldsSchema(),
+	custom: TagCustomFieldsSchema,
 	meta: Metadata
 });
 const RetrieveTagInput = z.object({ identifier: IdentifierInput });
@@ -45,4 +46,4 @@ const ListTagInput = z.object({
 });
 
 //#endregion
-export { ListTagInput, RetrieveTagInput, Tag, TagList };
+export { ListTagInput, RetrieveTagInput, Tag, TagCustomFieldsSchema, TagList };

package/dist/wordpress/generate.js

@@ -300,6 +300,28 @@ function renderEndpointNode(node, indent) {
 	if (entries.length === 0) return "{}";
 	return `{\n${entries.join("\n")}\n${indent.slice(0, -1)}}`;
 }
+function renderEndpointRegistry(node, path = []) {
+	const entries = [];
+	for (const [key, child] of sortedChildren(node)) entries.push(...renderEndpointRegistry(child, [...path, key]));
+	for (const entry of sortedEndpoints(node)) {
+		const input = endpointName(entry.apiId, entry.operationId, "EndpointInput");
+		const result = endpointName(entry.apiId, entry.operationId, "EndpointResult");
+		entries.push(`\t\t${JSON.stringify([...path, entry.member].join("."))}: WP_Endpoint<${input}, ${result}>`);
+	}
+	return entries;
+}
+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);
+		if (!match) continue;
+		const namespace = match[1] === "post-types" ? "postTypes" : "taxonomies";
+		const slug = match[2];
+		if (!slug) continue;
+		entries.push(`\t\t${JSON.stringify(`${namespace}.${camel(slug)}`)}: ${schemaName(id)}["kizlo"]["custom"]`);
+	}
+	return entries;
+}
 function operationEntries(apiId, api) {
 	const entries = [];
 	for (const [, operations] of sortedEntries(api.paths)) for (const [operationId, operation] of sortedEntries(operations)) entries.push([operationId, operation]);
@@ -349,13 +371,29 @@ const RUNTIME_TYPES = [
 	"WP_Success",
 	"WP_TransportFailure"
 ];
-const REGISTRY = `declare module "kizlo" {\n\tinterface WordPressClientRegistry {\n\t\tendpoints: typeof endpoints\n\t}\n}`;
+function renderRegistries(tree, document) {
+	const endpoints = renderEndpointRegistry(tree);
+	const customFields = renderCustomFieldsRegistry(document);
+	return [
+		`declare module "kizlo" {`,
+		`\tinterface WordPressClientRegistry {`,
+		`\t\tendpoints: typeof endpoints`,
+		`\t}`,
+		`\tinterface WordPressEndpointRegistry {`,
+		...endpoints,
+		`\t}`,
+		`\tinterface WordPressCustomFieldsRegistry {`,
+		...customFields,
+		`\t}`,
+		`}`
+	].join("\n");
+}
 /**
 * The `kizlo` names a generated module uses. `wpEndpoint` is the only value among them, so the rest
 * erase at build.
 */
 function kizloImports(body, hasEndpoints) {
-	const types = new Set(["WP_Client", ...RUNTIME_TYPES.filter((name) => (/* @__PURE__ */ new RegExp(`\\b${name}\\b`)).test(body))]);
+	const types = new Set(["WP_Client", ...["WP_Endpoint", ...RUNTIME_TYPES].filter((name) => (/* @__PURE__ */ new RegExp(`\\b${name}\\b`)).test(body))]);
 	const values = hasEndpoints ? ["wpEndpoint"] : [];
 	return [...types, ...values].sort().map((name) => types.has(name) ? `type ${name}` : name).join(", ");
 }
@@ -389,7 +427,7 @@ function generateWordPressModule(document) {
 		body,
 		`export const endpoints = ${endpointBody}`,
 		`export type WordPressClient = WP_Client<typeof endpoints>`,
-		REGISTRY
+		renderRegistries(tree, document)
 	].join(DECLARATION_SEPARATOR);
 	const imports = `import { ${kizloImports(moduleBody, endpointBody !== "{}")} } from "kizlo"`;
 	const preamble = `${GENERATED_HEADER}// Introspection ${document.hash}\n\n${imports}\n\n`;

package/dist/wordpress/index.d.ts

@@ -1,5 +1,5 @@
 import { WP_Error } from "./error.js";
-import { ActiveWordPressClient, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointInput, WP_EndpointResult, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_ResponseContentType, WP_Result, WP_Success, WP_TransportFailure, WP_TypedHeaders, WordPressClientRegistry, WordPressCredentials } from "./types.js";
+import { ActiveWordPressClient, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_CustomFields, WP_CustomFieldsPath, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointError, WP_EndpointInput, WP_EndpointPath, WP_EndpointResult, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_ResponseContentType, WP_Result, WP_Success, WP_TransportFailure, WP_TypedHeaders, WordPressClientRegistry, WordPressCredentials, WordPressCustomFieldsRegistry, WordPressEndpointRegistry } from "./types.js";
 import { WordPressTransport, WordPressTransportOptions, WordPressTransportResult } from "./transport.js";
 import { buildWordPressRequest, createWordPressClient, wpEndpoint } from "./endpoint.js";
 import { isWordPressResourceError } from "./utils.js";

package/dist/wordpress/types.d.ts

@@ -38,6 +38,10 @@ type WP_CallArguments<TInput$1> = Record<string, never> extends TInput$1 ? [inpu
 type IsAny<T> = 0 extends 1 & T ? true : false;
 /** Generated WordPress endpoint trees augment this registry in the project that owns them. */
 interface WordPressClientRegistry {}
+/** Generated WordPress modules augment this flat registry with every raw operation they expose. */
+interface WordPressEndpointRegistry {}
+/** Generated WordPress modules augment this registry from managed-content item schemas. */
+interface WordPressCustomFieldsRegistry {}
 /**
  * The WordPress client this project compiles against: its generated endpoints bound to the
  * transport, or the bare transport. The stub written before the first generation registers `any`,
@@ -46,9 +50,15 @@ interface WordPressClientRegistry {}
 type ActiveWordPressClient = WordPressClientRegistry extends {
   endpoints: infer TEndpoints extends object;
 } ? WP_Client<TEndpoints> & WordPressTransport : WordPressTransport;
-/** Walk a dotted endpoint path (`postTypes.post.retrieve`) into the active client. */
-type WP_EndpointAtPath<TClient, TPath extends string> = TPath extends `${infer TKey}.${infer TRest}` ? TKey extends keyof TClient ? WP_EndpointAtPath<TClient[TKey], TRest> : never : TPath extends keyof TClient ? TClient[TPath] : never;
-type WP_EndpointCallResult<TEndpoint> = IsAny<TEndpoint> extends true ? any : TEndpoint extends ((input: never) => Promise<infer TResult>) ? TResult : never;
+/** Every raw WordPress operation path generated for the active project. */
+type WP_EndpointPath = keyof WordPressEndpointRegistry extends never ? string : Extract<keyof WordPressEndpointRegistry, string>;
+/**
+ * Resolve a generated registry entry. The empty-registry branch keeps the package declarations
+ * usable before a project writes its first generated module; the generated stub adds the same
+ * permissive fallback explicitly.
+ */
+type WP_EndpointAtPath<TPath extends WP_EndpointPath> = keyof WordPressEndpointRegistry extends never ? any : TPath extends keyof WordPressEndpointRegistry ? WordPressEndpointRegistry[TPath] : never;
+type WP_EndpointCallResult<TEndpoint> = IsAny<TEndpoint> extends true ? any : TEndpoint extends WP_Endpoint<any, infer TResult> ? TResult : never;
 /**
  * `never` is short-circuited rather than let through: every type is assignable to it, so an
  * unresolved path would otherwise match the `{ data: infer TData }` branch and infer `unknown`,
@@ -65,21 +75,33 @@ type WP_EndpointSuccessData<TEndpoint> = IsAny<TEndpoint> extends true ? any : [
  * resolves against whichever client is compiling, so it stays well-formed in a project that has
  * not generated one yet (`any`) or whose WordPress does not serve the endpoint (`never`).
  */
-type WP_EndpointData<TPath extends string> = WP_EndpointSuccessData<WP_EndpointAtPath<ActiveWordPressClient, TPath>>;
+type WP_EndpointData<TPath extends WP_EndpointPath> = WP_EndpointSuccessData<WP_EndpointAtPath<TPath>>;
 /**
  * Everything a generated endpoint resolves to, success and failure alike, addressed the same way.
  * {@link WP_EndpointData} is the success payload on its own; this is what a signature that has to
  * name the whole result uses, so a service can publish its return type without the project's
  * generated module leaking into the package's own declarations.
  */
-type WP_EndpointResult<TPath extends string> = WP_EndpointCallResult<WP_EndpointAtPath<ActiveWordPressClient, TPath>>;
-type WP_EndpointCallInput<TEndpoint> = IsAny<TEndpoint> extends true ? any : TEndpoint extends ((...args: infer TArguments) => unknown) ? Exclude<TArguments[0], undefined> : never;
+type WP_EndpointResult<TPath extends WP_EndpointPath> = WP_EndpointCallResult<WP_EndpointAtPath<TPath>>;
+type WP_EndpointCallInput<TEndpoint> = IsAny<TEndpoint> extends true ? any : TEndpoint extends WP_Endpoint<infer TInput, any> ? TInput : never;
 /**
  * What a generated endpoint accepts, addressed the same way as {@link WP_EndpointData}. Kizlo's own
  * modules name their WordPress payloads with this rather than restating them, so an input can only
  * drift from the route it is sent to by the route itself changing.
  */
-type WP_EndpointInput<TPath extends string> = WP_EndpointCallInput<WP_EndpointAtPath<ActiveWordPressClient, TPath>>;
+type WP_EndpointInput<TPath extends WP_EndpointPath> = WP_EndpointCallInput<WP_EndpointAtPath<TPath>>;
+type WP_EndpointCallError<TEndpoint> = IsAny<TEndpoint> extends true ? any : TEndpoint extends WP_Endpoint<any, infer TResult> ? Exclude<TResult extends {
+  error: infer TError;
+} ? TError : never, null> : never;
+/** The non-null WordPress error returned by a generated raw endpoint. */
+type WP_EndpointError<TPath extends WP_EndpointPath> = WP_EndpointCallError<WP_EndpointAtPath<TPath>>;
+/** Every canonical managed-content custom-field mapping generated for the active project. */
+type WP_CustomFieldsPath = keyof WordPressCustomFieldsRegistry extends never ? string : Extract<keyof WordPressCustomFieldsRegistry, string>;
+/**
+ * Exact custom fields from a managed post type or taxonomy's canonical item schema. The fallback
+ * remains permissive until a generated module augments the registry with the project's mappings.
+ */
+type WP_CustomFields<TPath extends WP_CustomFieldsPath> = keyof WordPressCustomFieldsRegistry extends never ? Record<string, unknown> : TPath extends keyof WordPressCustomFieldsRegistry ? WordPressCustomFieldsRegistry[TPath] : never;
 /**
  * The codes that widen every endpoint's own union, because no introspection document can declare
  * them. `rest_no_route` is the answer when the route does not exist, which no route can describe
@@ -174,13 +196,13 @@ type WP_Success<TData$1, TStatus extends number = number, THeaders extends Recor
   headers: WP_TypedHeaders<THeaders, THeaderName>;
   error: null;
 };
-type WP_Failure<TError extends string, TStatus extends number = number, THeaders extends Record<string, unknown> = Record<string, never>, THeaderName extends string = string> = {
+type WP_Failure<TError$1 extends string, TStatus extends number = number, THeaders extends Record<string, unknown> = Record<string, never>, THeaderName extends string = string> = {
   data: null;
   status: TStatus;
   headers: WP_TypedHeaders<THeaders, THeaderName>;
-  error: WP_Error<TError>;
+  error: WP_Error<TError$1>;
 };
-type WP_TransportFailure<TError extends string, THeaderName extends string = string> = WP_Failure<TError, 0, Record<string, never>, THeaderName>;
-type WP_Result<TData$1, TError extends string> = WP_Success<TData$1> | WP_Failure<TError>;
+type WP_TransportFailure<TError$1 extends string, THeaderName extends string = string> = WP_Failure<TError$1, 0, Record<string, never>, THeaderName>;
+type WP_Result<TData$1, TError$1 extends string> = WP_Success<TData$1> | WP_Failure<TError$1>;
 //#endregion
-export { ActiveWordPressClient, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointInput, WP_EndpointResult, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_ResponseContentType, WP_Result, WP_Success, WP_TransportFailure, WP_TypedHeaders, WordPressClientRegistry, WordPressCredentials };
+export { ActiveWordPressClient, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_CustomFields, WP_CustomFieldsPath, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointError, WP_EndpointInput, WP_EndpointPath, WP_EndpointResult, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_ResponseContentType, WP_Result, WP_Success, WP_TransportFailure, WP_TypedHeaders, WordPressClientRegistry, WordPressCredentials, WordPressCustomFieldsRegistry, WordPressEndpointRegistry };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizlo",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "description": "A headless WordPress framework for TypeScript.",
   "keywords": [