kizlo 0.17.0 → 0.19.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/test/auth.js

@@ -1,10 +1,9 @@
 //#region src/test/auth.ts
 function testAuthAdapter(user) {
-	return { getUser() {
+	return { getSession() {
 		return {
-			id: user.wpUserId,
+			id: user.id,
 			email: user.email,
-			phone: user.phone,
 			firstName: user.firstName,
 			lastName: user.lastName
 		};

package/dist/test/users.d.ts

@@ -2,12 +2,10 @@ import { TestCredentials } from "../cli/wp/types.js";
 
 //#region src/test/users.d.ts
 interface TestAuthAdapterUser {
-  wpUserId: number;
-  username: string;
+  id: string;
+  email: string;
   firstName: string;
   lastName: string;
-  email: string;
-  phone: string;
 }
 declare function toTestUser(user: TestCredentials["users"]["user"]): TestAuthAdapterUser;
 //#endregion

package/dist/test/users.js

@@ -1,15 +1,10 @@
 //#region src/test/users.ts
-const STATIC_FIELDS = {
-	firstName: "Test",
-	lastName: "Customer",
-	email: "customer@example.com",
-	phone: "+10000000002"
-};
 function toTestUser(user) {
 	return {
-		wpUserId: user.id,
-		username: user.username,
-		...STATIC_FIELDS
+		id: String(user.id),
+		email: user.email,
+		firstName: "Test",
+		lastName: "Customer"
 	};
 }
 

package/dist/test.d.ts

@@ -1,5 +1,5 @@
 import { DevPluginSource, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, JsonValue, LocalPlugin, PluginSource, SeedContext, SettleContext, TestAdminUser, TestCredentials, TestUser, defineFixture, isLocalPlugin } from "./cli/wp/types.js";
-import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, WORDPRESS_CLIENT_META_REL, WORDPRESS_META_REL, githubRelease, kizloRelease } from "./cli/wp/constants.js";
+import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease } from "./cli/wp/constants.js";
 import { DockerStack, DockerStatus, RunResult, Stack, StackStatus, compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, dockerHint, dockerStatus, runningProjectContainers, stackStatus, stopProjectContainers, wpCli, wpEval } from "./cli/wp/docker.js";
 import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, isSeeded, recordedPort, resolvePluginSource, settleFixtures } from "./cli/wp/utils.js";
 import { TestAuthAdapterUser, toTestUser } from "./test/users.js";
@@ -8,4 +8,4 @@ import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
 import { menuFixture } from "./menu/fixture.js";
 import { postFixture } from "./post/fixture.js";
 import { coreFixtures } from "./test/fixtures.js";
-export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, DevPluginSource, DockerStack, DockerStatus, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, JsonValue, LOCAL_DIR_REL, LocalPlugin, OPCACHE_INI, PluginSource, REMAP_ENTRYPOINT, RunResult, SEED_MARKER_OPTION, SEED_VERSION, SeedContext, SettleContext, Stack, StackStatus, TEST_ADMIN, TEST_USER, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, WORDPRESS_CLIENT_META_REL, WORDPRESS_META_REL, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };
+export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, DevPluginSource, DockerStack, DockerStatus, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, INTROSPECTION_META_REL, JsonValue, LOCAL_DIR_REL, LocalPlugin, OPCACHE_INI, PluginSource, REMAP_ENTRYPOINT, RunResult, SEED_MARKER_OPTION, SEED_VERSION, SeedContext, SettleContext, Stack, StackStatus, TEST_ADMIN, TEST_USER, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };

package/dist/test.js

@@ -1,5 +1,5 @@
 import { defineFixture, isLocalPlugin } from "./cli/wp/types.js";
-import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, WORDPRESS_CLIENT_META_REL, WORDPRESS_META_REL, githubRelease, kizloRelease } from "./cli/wp/constants.js";
+import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease } from "./cli/wp/constants.js";
 import { compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, dockerHint, dockerStatus, runningProjectContainers, stackStatus, stopProjectContainers, wpCli, wpEval } from "./cli/wp/docker.js";
 import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, isSeeded, recordedPort, resolvePluginSource, settleFixtures } from "./cli/wp/utils.js";
 import { testAuthAdapter } from "./test/auth.js";
@@ -9,4 +9,4 @@ import { postFixture } from "./post/fixture.js";
 import { coreFixtures } from "./test/fixtures.js";
 import { toTestUser } from "./test/users.js";
 
-export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, WORDPRESS_CLIENT_META_REL, WORDPRESS_META_REL, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };
+export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };

package/dist/wordpress/endpoint.js

@@ -66,7 +66,8 @@ function buildWordPressRequest(definition, input) {
 				body: rest,
 				requestContentType: definition.requestContentType
 			} : { searchParams: rest },
-			responseContentTypes: definition.responseContentTypes
+			responseContentTypes: definition.responseContentTypes,
+			dataResponseStatuses: definition.dataResponseStatuses
 		},
 		error: null
 	};

package/dist/wordpress/error.d.ts

@@ -3,6 +3,7 @@ import { WP_CommonErrorCode, WP_ErrorData } from "./types.js";
 //#region src/wordpress/error.d.ts
 declare class WP_Error<TCode extends string = string> extends Error {
   code: TCode | WP_CommonErrorCode;
+  readonly data: unknown;
   constructor(error: WP_ErrorData<TCode>);
 }
 //#endregion

package/dist/wordpress/error.js

@@ -1,10 +1,12 @@
 //#region src/wordpress/error.ts
 var WP_Error = class extends Error {
 	code;
+	data;
 	constructor(error) {
 		super(error.message ?? "Internal server error, please try again.");
 		this.name = "WordPress Error";
 		this.code = error.code;
+		this.data = error.data ?? null;
 	}
 };
 

package/dist/wordpress/fetch-introspection.js

@@ -6,7 +6,7 @@ import { PLUGIN_VERSION_HEADER } from "@kizlo/shared";
 * WordPress could not be asked, or did not answer with a contract: a transport failure, a non-2xx
 * status, a body that is not JSON. A document that parsed is never one of these, however much of it
 * WordPress had to exclude, because what to do about an exclusion is the generator's policy and not
-* this function's. It reports; {@link generateWordPressOnce} decides.
+* this function's. It reports; {@link generateIntrospectionOnce} decides.
 */
 var IntrospectionFetchError = class extends Error {
 	/**

package/dist/wordpress/generate.js

@@ -182,6 +182,9 @@ function responseStatus(status) {
 function isSuccessStatus(status) {
 	return /^2\d\d$/.test(status);
 }
+function isWordPressErrorResponse(response) {
+	return response.body?.$ref === "kizlo.error";
+}
 /**
 * Every failing status of an endpoint carries the same error union, so spelling one member per
 * status would repeat it four or five times for no discrimination anyone can act on. They collapse
@@ -193,10 +196,10 @@ function renderResult(apiId, operationId, operation, context) {
 	const name = endpointName(apiId, operationId, "EndpointResult");
 	const errors = operation.errors.map(literal).join(" | ") || "never";
 	const responses = sortedEntries(operation.responses);
-	const failures = responses.filter(([status]) => !isSuccessStatus(status));
+	const failures = responses.filter(([, response]) => isWordPressErrorResponse(response));
 	const headerNames = [...new Set(responses.flatMap(([, response]) => responseHeaderNames(response, context)))].sort((left, right) => left.localeCompare(right)).map(literal).join(" | ");
 	const sharedHeaderNames = headerNames ? `, ${headerNames}` : "";
-	const variants = responses.filter(([status]) => isSuccessStatus(status)).map(([status, response]) => `WP_Success<${responseBody(response, context)}, ${status}, ${responseHeaders(response, context)}${sharedHeaderNames}>`);
+	const variants = responses.filter(([, response]) => !isWordPressErrorResponse(response)).map(([status, response]) => `WP_Success<${responseBody(response, context)}, ${status}, ${responseHeaders(response, context)}${sharedHeaderNames}>`);
 	if (new Set([NO_HEADERS, ...failures.map(([, response]) => responseHeaders(response, context))]).size === 1) variants.push(`WP_Failure<${errors}, number, ${NO_HEADERS}${sharedHeaderNames}>`);
 	else {
 		for (const [status, response] of failures) variants.push(`WP_Failure<${errors}, ${responseStatus(status)}, ${responseHeaders(response, context)}${sharedHeaderNames}>`);
@@ -257,13 +260,15 @@ function sortedEndpoints(node) {
 function endpointDefinition(entry) {
 	const pathParameters = sortedEntries(entry.operation.input.properties ?? {}).filter(([, schema]) => schema.in === "path").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 {
 		namespace: entry.namespace,
 		path: entry.path,
 		method: entry.operation.method,
 		pathParameters,
 		...entry.operation.input.content_type ? { requestContentType: entry.operation.input.content_type } : {},
-		responseContentTypes
+		responseContentTypes,
+		...dataResponseStatuses.length > 0 ? { dataResponseStatuses } : {}
 	};
 }
 function renderRecord(value) {
@@ -279,7 +284,8 @@ function renderDefinition(definition) {
 		`method: ${literal(definition.method)}`,
 		`pathParameters: [${definition.pathParameters.map(literal).join(", ")}]`,
 		...definition.requestContentType ? [`requestContentType: ${literal(definition.requestContentType)}`] : [],
-		`responseContentTypes: ${renderRecord(definition.responseContentTypes)}`
+		`responseContentTypes: ${renderRecord(definition.responseContentTypes)}`,
+		...definition.dataResponseStatuses?.length ? [`dataResponseStatuses: [${definition.dataResponseStatuses.map(literal).join(", ")}]`] : []
 	].join(", ")} }`;
 }
 /**
@@ -300,6 +306,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 +377,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 +433,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";