kizlo 0.7.0 → 0.8.0

package/dist/router.js

@@ -1,12 +1,18 @@
+import { CATEGORY_ROUTER_MAP } from "./category/index.js";
 import { COMMENT_ROUTER_MAP } from "./comment/index.js";
 import { MENU_ROUTER_MAP } from "./menu/index.js";
+import { PAGE_ROUTER_MAP } from "./page/index.js";
 import { POST_ROUTER_MAP } from "./post/index.js";
 import { SEO_ROUTER_MAP } from "./seo/index.js";
 import { SETTINGS_ROUTER_MAP } from "./settings/index.js";
+import { TAG_ROUTER_MAP } from "./tag/index.js";
 
 //#region src/router.ts
 const ROUTER_MAP = {
 	posts: POST_ROUTER_MAP,
+	pages: PAGE_ROUTER_MAP,
+	categories: CATEGORY_ROUTER_MAP,
+	tags: TAG_ROUTER_MAP,
 	seo: SEO_ROUTER_MAP,
 	menus: MENU_ROUTER_MAP,
 	comments: COMMENT_ROUTER_MAP,

package/dist/seo/index.js

@@ -1,6 +1,7 @@
 import { createProcedure } from "../shared/procedure.js";
 import { WP_KIZLO_BASE } from "../wordpress/constants.js";
 import { ListSitemapUrlInput, Robots, Seo, SitemapIndex, SitemapList, SitemapUrlList } from "./schema.js";
+import { deserializeSeo } from "./utils.js";
 
 //#region src/seo/index.ts
 const SEO_ROUTER_MAP = {
@@ -8,57 +9,19 @@ const SEO_ROUTER_MAP = {
 		scope: "internal",
 		output: Seo
 	}, async ({ context, errors }) => {
-		const response = await context.service.wordpress.get("/seo/homepage", { base: WP_KIZLO_BASE });
+		const response = await context.wordpress.get("/seo/homepage", { base: WP_KIZLO_BASE });
 		if (response.error) {
 			context.logger.error("Get homepage seo unhandled error", response.error);
 			throw errors.INTERNAL_SERVER_ERROR();
 		}
-		const { head } = response.data;
-		return {
-			head: {
-				title: head.title,
-				canonical: head.canonical,
-				robots: {
-					index: head.robots.index,
-					follow: head.robots.follow,
-					maxSnippet: head.robots["max-snippet"],
-					maxImagePreview: head.robots["max-image-preview"],
-					maxVideoPreview: head.robots["max-video-preview"]
-				},
-				og: {
-					locale: head.og.locale,
-					type: head.og.type,
-					title: head.og.title,
-					url: head.og.url,
-					siteName: head.og.site_name,
-					description: head.og.description ?? "",
-					image: head.og.image
-				},
-				twitter: {
-					card: head.twitter.card,
-					title: head.twitter.title,
-					site: head.twitter.site,
-					creator: head.twitter.creator,
-					description: head.twitter.description ?? "",
-					image: head.twitter.image
-				},
-				article: head.article && {
-					publishedTime: head.article.published_time,
-					modifiedTime: head.article.modified_time,
-					author: head.article.author,
-					authorUrl: head.article.author_url,
-					section: head.article.section
-				}
-			},
-			schema: response.data.schema
-		};
+		return deserializeSeo(response.data);
 	}),
 	sitemaps: {
 		list: createProcedure({
 			scope: "internal",
 			output: SitemapList
 		}, async ({ context, errors }) => {
-			const response = await context.service.wordpress.get("/seo/sitemaps", { base: WP_KIZLO_BASE });
+			const response = await context.wordpress.get("/seo/sitemaps", { base: WP_KIZLO_BASE });
 			if (response.error) {
 				context.logger.error("List sitemaps unhandled error", response.error);
 				throw errors.INTERNAL_SERVER_ERROR();
@@ -69,7 +32,7 @@ const SEO_ROUTER_MAP = {
 			scope: "internal",
 			output: SitemapIndex
 		}, async ({ context, errors }) => {
-			const response = await context.service.wordpress.get("/seo/sitemaps/index", { base: WP_KIZLO_BASE });
+			const response = await context.wordpress.get("/seo/sitemaps/index", { base: WP_KIZLO_BASE });
 			if (response.error) {
 				context.logger.error("Get sitemap index unhandled error", response.error);
 				throw errors.INTERNAL_SERVER_ERROR();
@@ -84,7 +47,7 @@ const SEO_ROUTER_MAP = {
 		scope: "internal",
 		output: Robots
 	}, async ({ context, errors }) => {
-		const response = await context.service.wordpress.get(`/seo/robots`, { base: WP_KIZLO_BASE });
+		const response = await context.wordpress.get(`/seo/robots`, { base: WP_KIZLO_BASE });
 		if (response.error) {
 			context.logger.error("List robots unhandled error", response.error);
 			throw errors.INTERNAL_SERVER_ERROR();
@@ -103,7 +66,7 @@ const SEO_ROUTER_MAP = {
 		output: SitemapUrlList,
 		input: ListSitemapUrlInput
 	}, async ({ context, input, errors }) => {
-		const response = await context.service.wordpress.get(`/seo/sitemaps/${input.type}/${input.type !== "author" ? input.key : ""}`, {
+		const response = await context.wordpress.get(`/seo/sitemaps/${input.type}/${input.type !== "author" ? input.key : ""}`, {
 			base: WP_KIZLO_BASE,
 			searchParams: { page: input.page ?? 1 }
 		});

package/dist/seo/schema.d.ts

@@ -20,9 +20,9 @@ declare const SeoHead: z.ZodObject<{
     description: z.ZodString;
     image: z.ZodNullable<z.ZodObject<{
       url: z.ZodString;
-      width: z.ZodString;
-      height: z.ZodString;
-      type: 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>;
@@ -36,6 +36,7 @@ declare const SeoHead: z.ZodObject<{
     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;
@@ -43,6 +44,7 @@ declare const SeoHead: z.ZodObject<{
     author: z.ZodString;
     authorUrl: z.ZodString;
     section: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
 type SeoHead = z.infer<typeof SeoHead>;
@@ -71,9 +73,9 @@ declare const Seo: z.ZodObject<{
       description: z.ZodString;
       image: z.ZodNullable<z.ZodObject<{
         url: z.ZodString;
-        width: z.ZodString;
-        height: z.ZodString;
-        type: 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>;
@@ -87,6 +89,7 @@ declare const Seo: z.ZodObject<{
       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;
@@ -94,6 +97,7 @@ declare const Seo: z.ZodObject<{
       author: z.ZodString;
       authorUrl: z.ZodString;
       section: z.ZodString;
+      tags: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
   }, z.core.$strip>;
   schema: z.ZodObject<{

package/dist/seo/schema.js

@@ -21,9 +21,9 @@ const SeoHead = z.object({
 		description: z.string(),
 		image: z.object({
 			url: z.string(),
-			width: z.string(),
-			height: z.string(),
-			type: z.string(),
+			width: z.number().nullable(),
+			height: z.number().nullable(),
+			type: z.string().nullable(),
 			alt: z.string().nullable()
 		}).nullable()
 	}),
@@ -33,14 +33,16 @@ const SeoHead = z.object({
 		site: z.string().nullable(),
 		creator: z.string().nullable(),
 		description: z.string(),
-		image: z.string().nullable()
+		image: z.string().nullable(),
+		imageAlt: z.string().nullable()
 	}),
 	article: z.object({
 		publishedTime: z.string(),
 		modifiedTime: z.string(),
 		author: z.string(),
 		authorUrl: z.string(),
-		section: z.string()
+		section: z.string(),
+		tags: z.array(z.string())
 	}).nullable()
 });
 const SeoSchema = z.object({

package/dist/seo/sitemap.d.ts

@@ -35,5 +35,13 @@ interface CreateSitemapRouteOptions {
  * integration) add mount assertions on top.
  */
 declare function createSitemapRoute(client: S2SClient<[]>, options?: CreateSitemapRouteOptions): (request: Request) => Promise<Response>;
+/**
+ * Builds a handler that permanently redirects the well-known `/sitemap.xml` to the generated
+ * sitemap index at `/sitemaps/index.xml`. Crawlers probe the standard path regardless of what
+ * robots.txt advertises, so this points them at the real index. The target is derived from the
+ * same `SITEMAP_BASE`/`SITEMAP_INDEX_SLUG` constants the sitemap route is mounted on, so there is
+ * a single source of truth for where the index lives. Framework-agnostic like `createSitemapRoute`.
+ */
+declare function createSitemapRedirectRoute(): (_request: Request) => Response;
 //#endregion
-export { CreateSitemapRouteOptions, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SitemapRouteExtra, createSitemapRoute };
+export { CreateSitemapRouteOptions, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SitemapRouteExtra, createSitemapRedirectRoute, createSitemapRoute };

package/dist/seo/sitemap.js

@@ -53,6 +53,22 @@ function createSitemapRoute(client, options) {
 		return xmlResponse(renderUrlSet(data));
 	};
 }
+/**
+* Builds a handler that permanently redirects the well-known `/sitemap.xml` to the generated
+* sitemap index at `/sitemaps/index.xml`. Crawlers probe the standard path regardless of what
+* robots.txt advertises, so this points them at the real index. The target is derived from the
+* same `SITEMAP_BASE`/`SITEMAP_INDEX_SLUG` constants the sitemap route is mounted on, so there is
+* a single source of truth for where the index lives. Framework-agnostic like `createSitemapRoute`.
+*/
+function createSitemapRedirectRoute() {
+	const location = `${SITEMAP_BASE}/${SITEMAP_INDEX_SLUG}`;
+	return function GET(_request) {
+		return new Response(null, {
+			status: 308,
+			headers: { Location: location }
+		});
+	};
+}
 function lastPathSegment(url) {
 	return decodeURIComponent(url.pathname.split("/").filter(Boolean).pop() ?? "");
 }
@@ -61,4 +77,4 @@ function notFound() {
 }
 
 //#endregion
-export { SITEMAP_BASE, SITEMAP_INDEX_SLUG, createSitemapRoute };
+export { SITEMAP_BASE, SITEMAP_INDEX_SLUG, createSitemapRedirectRoute, createSitemapRoute };

package/dist/seo/types.d.ts

@@ -16,29 +16,31 @@ interface WPK_Seo {
       title: string;
       url: string;
       site_name: string;
-      description: string;
-      image: {
+      description?: string;
+      image?: {
         url: string;
-        width: string;
-        height: string;
-        type: string;
+        width: number | null;
+        height: number | null;
+        type: string | null;
         alt: string | null;
-      } | null;
+      };
     };
     twitter: {
-      card: "summary_large_image";
+      card: "summary" | "summary_large_image";
       title: string;
       site: string | null;
       creator: string | null;
-      description: string;
-      image: string | null;
+      description?: string;
+      image?: string;
+      image_alt?: string;
     };
     article: {
-      published_time: string;
-      modified_time: string;
-      author: string;
-      author_url: string;
-      section: string;
+      published_time?: string;
+      modified_time?: string;
+      author?: string;
+      author_url?: string;
+      section?: string;
+      tags?: string[];
     } | null;
   };
   schema: {
@@ -75,10 +77,5 @@ interface WPK_SitemapUrl {
   lastmod: string;
   images: WPK_SitemapUrlImage[];
 }
-interface WPK_ListSitemapUrlInput {
-  type: WPK_SitemapContentType;
-  key?: string;
-  page?: number;
-}
 //#endregion
-export { WPK_ListSitemapUrlInput, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage };
+export { WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapContentType, WPK_SitemapIndex, WPK_SitemapUrl, WPK_SitemapUrlImage };

package/dist/seo/utils.js

@@ -3,15 +3,16 @@ function deserializeSeo(data) {
 	return {
 		head: {
 			article: data.head.article ? {
-				author: data.head.article.author,
-				authorUrl: data.head.article.author_url,
-				modifiedTime: data.head.article.modified_time,
-				publishedTime: data.head.article.published_time,
-				section: data.head.article.section
+				author: data.head.article.author ?? "",
+				authorUrl: data.head.article.author_url ?? "",
+				modifiedTime: data.head.article.modified_time ?? "",
+				publishedTime: data.head.article.published_time ?? "",
+				section: data.head.article.section ?? "",
+				tags: data.head.article.tags ?? []
 			} : null,
 			canonical: data.head.canonical,
 			og: {
-				description: data.head.og.description,
+				description: data.head.og.description ?? "",
 				image: data.head.og.image ?? null,
 				locale: data.head.og.locale,
 				siteName: data.head.og.site_name,
@@ -30,8 +31,9 @@ function deserializeSeo(data) {
 			twitter: {
 				card: data.head.twitter.card,
 				creator: data.head.twitter.creator,
-				description: data.head.twitter.description,
+				description: data.head.twitter.description ?? "",
 				image: data.head.twitter.image ?? null,
+				imageAlt: data.head.twitter.image_alt ?? null,
 				site: data.head.twitter.site,
 				title: data.head.twitter.title
 			}

package/dist/settings/index.js

@@ -1,12 +1,14 @@
 import { createProcedure, schemaType } from "../shared/procedure.js";
 
 //#region src/settings/index.ts
-/** Shared error handling for every settings write: `invalid_param` → 400, anything else → 500. */
+/** Shared error handling for every settings write: `invalid_param` → 400, `rest_forbidden` → 403, anything else → 500. */
 function resolveUpdate(response, context, errors, label) {
-	if (response.error) {
-		if (response.error.code === "invalid_param") throw errors.BAD_REQUEST({ message: response.error.message });
-		context.logger.error(`${label} unhandled error`, response.error);
-		throw errors.INTERNAL_SERVER_ERROR();
+	if (response.error) switch (response.error.code) {
+		case "invalid_param": throw errors.BAD_REQUEST({ message: response.error.message });
+		case "rest_forbidden": throw errors.FORBIDDEN({ message: response.error.message });
+		default:
+			context.logger.error(`${label} unhandled error`, response.error);
+			throw errors.INTERNAL_SERVER_ERROR();
 	}
 	return response.data;
 }
@@ -15,58 +17,59 @@ const SETTINGS_ROUTER_MAP = {
 		scope: "internal",
 		output: schemaType()
 	}, async ({ context, errors }) => {
-		const response = await context.service.settings.get();
+		const response = await context.settings.get();
 		if (response.error) {
+			if (response.error.code === "rest_forbidden") throw errors.FORBIDDEN({ message: response.error.message });
 			context.logger.error("Get settings unhandled error", response.error);
 			throw errors.INTERNAL_SERVER_ERROR();
 		}
 		return response.data;
 	}),
-	updateSite: createProcedure({
+	site: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateSite(input), context, errors, "Update site settings")),
-	updateBrand: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateSite(input), context, errors, "Update site settings")) },
+	brand: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateBrand(input), context, errors, "Update brand settings")),
-	updateIdentity: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateBrand(input), context, errors, "Update brand settings")) },
+	identity: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateIdentity(input), context, errors, "Update identity settings")),
-	updateAuthors: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateIdentity(input), context, errors, "Update identity settings")) },
+	authors: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateAuthors(input), context, errors, "Update authors settings")),
-	updateCrawling: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateAuthors(input), context, errors, "Update authors settings")) },
+	crawling: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateCrawling(input), context, errors, "Update crawling settings")),
-	updateWebhook: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateCrawling(input), context, errors, "Update crawling settings")) },
+	webhook: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateWebhook(input), context, errors, "Update webhook settings")),
-	updateUploads: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateWebhook(input), context, errors, "Update webhook settings")) },
+	uploads: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateUploads(input), context, errors, "Update uploads settings")),
-	updatePostType: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateUploads(input), context, errors, "Update uploads settings")) },
+	postType: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updatePostType(input.slug, input.data), context, errors, "Update post type settings")),
-	updateTaxonomy: createProcedure({
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updatePostType(input.key, input.data), context, errors, "Update post type settings")) },
+	taxonomy: { update: createProcedure({
 		scope: "internal",
 		input: schemaType(),
 		output: schemaType()
-	}, async ({ context, input, errors }) => resolveUpdate(await context.service.settings.updateTaxonomy(input.slug, input.data), context, errors, "Update taxonomy settings"))
+	}, async ({ context, input, errors }) => resolveUpdate(await context.settings.updateTaxonomy(input.key, input.data), context, errors, "Update taxonomy settings")) }
 };
 
 //#endregion

package/dist/settings/service.d.ts

@@ -1,23 +1,24 @@
 import { WP_Result } from "../wordpress/types.js";
-import { AuthorsSettingsInput, BrandSettingsInput, CrawlingSettingsInput, IdentitySettingsInput, PostTypeSettingsInput, Settings, SiteSettingsInput, TaxonomySettingsInput, UploadsSettingsInput, WebhookSettingsInput } from "./service.interface.js";
-import { Service } from "../service.js";
+import { WordPressService } from "../wordpress/service.js";
+import "../wordpress/index.js";
+import { AuthorsSettings, AuthorsSettingsInput, BrandSettings, BrandSettingsInput, CrawlingSettings, CrawlingSettingsInput, IdentitySettings, IdentitySettingsInput, PostTypeSettings, PostTypeSettingsInput, Settings, SiteSettings, SiteSettingsInput, TaxonomySettings, TaxonomySettingsInput, UploadsSettings, UploadsSettingsInput, WebhookSettings, WebhookSettingsInput } from "./service.interface.js";
 import "../index.js";
 
 //#region src/settings/service.d.ts
 declare class SettingsService {
-  private readonly service;
-  constructor(service: Service);
+  private readonly wordpress;
+  constructor(wordpress: WordPressService);
   /** Fetch every Kizlo settings section in one response. */
   get(): Promise<WP_Result<Settings, never>>;
-  updateSite(input: SiteSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateBrand(input: BrandSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateWebhook(input: WebhookSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateIdentity(input: IdentitySettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateAuthors(input: AuthorsSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateCrawling(input: CrawlingSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateUploads(input: UploadsSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updatePostType(slug: string, input: PostTypeSettingsInput): Promise<WP_Result<null, "invalid_param">>;
-  updateTaxonomy(slug: string, input: TaxonomySettingsInput): Promise<WP_Result<null, "invalid_param">>;
+  updateSite(input: SiteSettingsInput): Promise<WP_Result<SiteSettings, "invalid_param">>;
+  updateBrand(input: BrandSettingsInput): Promise<WP_Result<BrandSettings, "invalid_param">>;
+  updateWebhook(input: WebhookSettingsInput): Promise<WP_Result<WebhookSettings, "invalid_param">>;
+  updateIdentity(input: IdentitySettingsInput): Promise<WP_Result<IdentitySettings, "invalid_param">>;
+  updateAuthors(input: AuthorsSettingsInput): Promise<WP_Result<AuthorsSettings, "invalid_param">>;
+  updateCrawling(input: CrawlingSettingsInput): Promise<WP_Result<CrawlingSettings, "invalid_param">>;
+  updateUploads(input: UploadsSettingsInput): Promise<WP_Result<UploadsSettings, "invalid_param">>;
+  updatePostType(key: string, input: PostTypeSettingsInput): Promise<WP_Result<PostTypeSettings, "invalid_param">>;
+  updateTaxonomy(key: string, input: TaxonomySettingsInput): Promise<WP_Result<TaxonomySettings, "invalid_param">>;
   private update;
 }
 //#endregion

package/dist/settings/service.interface.d.ts

@@ -20,7 +20,7 @@ type IdentitySettingsInput = Partial<{
 type AuthorsSettingsInput = Partial<AuthorsSettings>;
 type CrawlingSettingsInput = Partial<CrawlingSettings>;
 type UploadsSettingsInput = Partial<UploadsSettings>;
-type PostTypeSettingsInput = Partial<Pick<PostTypeSettings, "title_structure" | "description_structure" | "search_engine_visibility" | "webpage_type" | "article_type" | "seo_enabled" | "pathname_structure" | "comment_action_structure" | "rest_api_enabled" | "publicly_queryable" | "breadcrumbs">>;
-type TaxonomySettingsInput = Partial<Pick<TaxonomySettings, "title_structure" | "description_structure" | "search_engine_visibility" | "seo_enabled" | "pathname_structure" | "rest_api_enabled" | "publicly_queryable" | "breadcrumbs">>;
+type PostTypeSettingsInput = Partial<Pick<PostTypeSettings, "title_structure" | "description_structure" | "search_engine_visibility" | "webpage_type" | "article_type" | "seo_enabled" | "pathname_structure" | "comment_action_structure" | "rest_api_enabled" | "breadcrumbs">>;
+type TaxonomySettingsInput = Partial<Pick<TaxonomySettings, "title_structure" | "description_structure" | "search_engine_visibility" | "seo_enabled" | "pathname_structure" | "rest_api_enabled" | "breadcrumbs">>;
 //#endregion
 export { type AuthorsSettings, AuthorsSettingsInput, type BrandSettings, BrandSettingsInput, type CrawlingSettings, CrawlingSettingsInput, type IdentitySettings, IdentitySettingsInput, type OrganizationFounder, type OrganizationSettings, OrganizationSettingsInput, type PersonSettings, PersonSettingsInput, type PostStatusDefinition, type PostTypeSettings, PostTypeSettingsInput, type Settings, type SiteSettings, SiteSettingsInput, type SocialProfile, type TaxonomySettings, TaxonomySettingsInput, type UploadsSettings, UploadsSettingsInput, type WebhookSettings, WebhookSettingsInput };

package/dist/settings/service.js

@@ -2,13 +2,13 @@ import { WP_KIZLO_BASE } from "../wordpress/constants.js";
 
 //#region src/settings/service.ts
 var SettingsService = class {
-	service;
-	constructor(service) {
-		this.service = service;
+	wordpress;
+	constructor(wordpress) {
+		this.wordpress = wordpress;
 	}
 	/** Fetch every Kizlo settings section in one response. */
 	async get() {
-		return this.service.wordpress.get("/settings", { base: WP_KIZLO_BASE });
+		return this.wordpress.get("/settings", { base: WP_KIZLO_BASE });
 	}
 	async updateSite(input) {
 		return this.update("/settings/site", input);
@@ -31,14 +31,14 @@ var SettingsService = class {
 	async updateUploads(input) {
 		return this.update("/settings/uploads", input);
 	}
-	async updatePostType(slug, input) {
-		return this.update(`/settings/post_types/${slug}`, input);
+	async updatePostType(key, input) {
+		return this.update(`/settings/post_types/${key}`, input);
 	}
-	async updateTaxonomy(slug, input) {
-		return this.update(`/settings/taxonomies/${slug}`, input);
+	async updateTaxonomy(key, input) {
+		return this.update(`/settings/taxonomies/${key}`, input);
 	}
 	async update(path, body) {
-		return this.service.wordpress.put(path, {
+		return this.wordpress.put(path, {
 			base: WP_KIZLO_BASE,
 			body
 		});

package/dist/shared/middleware.d.ts

@@ -1,11 +1,11 @@
 import { AnyContext } from "./types.js";
-import { ServerContext } from "../context.js";
+import { ProcedureContext } from "../context.js";
 import { DefinedErrorMapLike } from "./error.js";
 import { BaseHandlerOptions } from "./procedure.js";
 import { UnionToIntersection } from "@kizlo/shared";
 
 //#region src/shared/middleware.d.ts
-type InferUses<T extends readonly AnyMiddleware[] | undefined> = T extends readonly [] ? object : T extends readonly AnyMiddleware[] ? UnionToIntersection<ExtractMiddlewareContextOutput<T[number]>> : object;
+type InferMiddlewares<T extends readonly AnyMiddleware[] | undefined> = T extends readonly [] ? object : T extends readonly AnyMiddleware[] ? UnionToIntersection<ExtractMiddlewareContextOutput<T[number]>> : object;
 interface MiddlewareResult<TOutContext extends AnyContext, TOutput> {
   /** The handler's return value, as it flows back up through any middleware that awaited `next()`. */
   output: TOutput;
@@ -19,7 +19,7 @@ type MiddlewareNextFn<TOutput> = {
     context: UOutContext;
   }): Promise<MiddlewareResult<UOutContext, TOutput>>;
 };
-type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = BaseHandlerOptions<TInput, ServerContext, TError> & {
+type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = BaseHandlerOptions<TInput, ProcedureContext, TError> & {
   /** Run the next middleware (or the handler) and return its result; pass `{ context }` to extend the context for everything downstream. */
   next: MiddlewareNextFn<TOutput>;
 };
@@ -29,4 +29,4 @@ type AnyMiddleware = Middleware<any, any, any, any>;
 type ExtractMiddlewareContextOutput<M> = M extends Middleware<any, any, any, infer TOut> ? TOut : never;
 declare function createMiddleware<TInput = any, TOutput = any, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TOutContext extends AnyContext = AnyContext>(handler: MiddlewareHandler<TInput, TOutput, TError, TOutContext>): Middleware<TInput, TOutput, TError, TOutContext>;
 //#endregion
-export { AnyMiddleware, ExtractMiddlewareContextOutput, InferUses, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, createMiddleware };
+export { AnyMiddleware, ExtractMiddlewareContextOutput, InferMiddlewares, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, createMiddleware };

package/dist/shared/procedure.d.ts

@@ -1,6 +1,6 @@
-import { ServerContext } from "../context.js";
+import { ProcedureContext } from "../context.js";
 import { DefinedErrorMapLike, ThrowableErrorMap, WithCommonErrorMap } from "./error.js";
-import { AnyMiddleware, InferUses, Middleware } from "./middleware.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_server0 from "@orpc/server";
@@ -25,11 +25,11 @@ interface BaseHandlerOptions<TInput, TContext, TError extends DefinedErrorMapLik
 type InvocationScope = "internal" | "remote" | "api";
 /** Callable map of a procedure's declared error codes plus the built-in common HTTP errors. */
 type ProcedureErrors<TError extends DefinedErrorMapLike = DefinedErrorMapLike> = ThrowableErrorMap<WithCommonErrorMap<TError>>;
-type ProcedureHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TContext extends ServerContext> = (options: BaseHandlerOptions<TInput, TContext, TError>) => Promisify<TOutput>;
+type ProcedureHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TContext extends ProcedureContext> = (options: BaseHandlerOptions<TInput, TContext, TError>) => Promisify<TOutput>;
 interface Procedure<TScope extends InvocationScope, TInput, TOutput, TError extends DefinedErrorMapLike = DefinedErrorMapLike> {
   "~kizlo": {
     uses: AnyMiddleware[];
-    handler: ProcedureHandler<TInput, TOutput, TError, ServerContext>;
+    handler: ProcedureHandler<TInput, TOutput, TError, ProcedureContext>;
     options: {
       scope: TScope;
       errors?: TError;
@@ -56,7 +56,6 @@ interface Procedure<TScope extends InvocationScope, TInput, TOutput, TError exte
   };
 }
 type AnyProcedure = Procedure<InvocationScope, any, any, any>;
-type ProcedureContext<TMiddlewares extends AnyMiddleware[]> = ServerContext & InferUses<TMiddlewares>;
 type SchemaIO<TSchema, TMap extends "output" | "input"> = TMap extends "output" ? SchemaOutput<TSchema> : SchemaInput<TSchema>;
 type OpenapiPart<TKey extends string, TSchema, TMap extends "output" | "input"> = [TSchema] extends [never] ? unknown : [TSchema] extends [Schema] ? undefined extends SchemaIO<TSchema, TMap> ? { [K in TKey]?: SchemaIO<TSchema, TMap> } : { [K in TKey]: SchemaIO<TSchema, TMap> } : unknown;
 type ExtractParams<T extends string> = T extends `${string}{${infer Param}}${infer Rest}` ? { [K in Param | keyof ExtractParams<Rest>]: string } : object;
@@ -111,10 +110,10 @@ 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<TMiddlewares> = ProcedureContext<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 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 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;
 //#endregion
-export { AnyProcedure, AnyProcedureRouter, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType };
+export { AnyProcedure, AnyProcedureRouter, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureErrors, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType };

package/dist/tag/error.js

@@ -0,0 +1,14 @@
+import { defineErrorMap } from "../shared/error.js";
+
+//#region src/tag/error.ts
+const GET_TAG_ERROR_MAP = defineErrorMap({ TAG_NOT_FOUND: {
+	status: 404,
+	message: "Tag not found"
+} });
+const LIST_TAG_ERROR_MAP = defineErrorMap({ TAG_INVALID_PAGE: {
+	status: 400,
+	message: "The requested page does not exist."
+} });
+
+//#endregion
+export { GET_TAG_ERROR_MAP, LIST_TAG_ERROR_MAP };