kizlo 0.1.1 → 0.2.1

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

@@ -0,0 +1,134 @@
+//#region src/settings/service.interface.d.ts
+interface KizloMedia {
+  id: number;
+  url: string;
+}
+interface KizloSocialProfile {
+  url: string;
+  platform: string;
+}
+interface KizloSiteSettings {
+  url: string | null;
+  backend_url: string | null;
+  secret: string | null;
+  name: string | null;
+  alternate_name: string | null;
+  tagline: string | null;
+  title_separator: string;
+  fallback_image: KizloMedia | null;
+  search_action_structure: string | null;
+}
+interface KizloPersonSettings {
+  name: string;
+  image: KizloMedia | null;
+  social_profiles: KizloSocialProfile[];
+}
+interface KizloOrganizationFounder {
+  name: string;
+  social_profiles: KizloSocialProfile[];
+}
+interface KizloOrganizationSettings {
+  name: string;
+  alternate_name: string | null;
+  slogan: string | null;
+  description: string | null;
+  email: string | null;
+  phone: string | null;
+  legal_name: string | null;
+  founding_date: string | null;
+  founder: KizloOrganizationFounder | null;
+  employees: number | null;
+  logo: KizloMedia | null;
+  social_profiles: KizloSocialProfile[];
+}
+interface KizloIdentitySettings {
+  type: "person" | "organization";
+  person: KizloPersonSettings | null;
+  organization: KizloOrganizationSettings | null;
+}
+interface KizloBaseContentSettings {
+  title_structure: string | null;
+  description_structure: string | null;
+  search_engine_visibility: boolean | null;
+  webpage_type: string;
+  article_type: string | null;
+}
+interface KizloAuthorsSettings extends Omit<KizloBaseContentSettings, "webpage_type" | "article_type"> {
+  enabled: boolean;
+  pathname_structure: string | null;
+}
+interface KizloPostTypeSettings extends KizloBaseContentSettings {
+  name: string;
+  slug: string;
+  seo_enabled: boolean;
+  pathname_structure: string | null;
+  comment_action_structure: string | null;
+  rest_api_enabled: boolean;
+  internal: boolean;
+  publicly_queryable: boolean;
+  supports: Record<string, boolean>;
+}
+interface KizloTaxonomySettings extends Omit<KizloBaseContentSettings, "webpage_type" | "article_type"> {
+  name: string;
+  slug: string;
+  seo_enabled: boolean;
+  pathname_structure: string | null;
+  rest_api_enabled: boolean;
+  internal: boolean;
+  publicly_queryable: boolean;
+}
+interface KizloWebhookSettings {
+  post_types: string[];
+  taxonomies: string[];
+  webhook_urls: string[];
+}
+interface KizloCrawlingSettings {
+  sitemaps: {
+    pathname_structure: string;
+  };
+  robots: {
+    include_sitemap: boolean;
+    custom_rules: {
+      user_agent: string;
+      rule: "allow" | "disallow";
+      path: string;
+    }[];
+  };
+}
+interface KizloPostStatus {
+  label: string;
+  slug: string;
+  public: boolean;
+}
+interface KizloSettings {
+  site: KizloSiteSettings;
+  identity: KizloIdentitySettings;
+  authors: KizloAuthorsSettings;
+  post_types: KizloPostTypeSettings[];
+  taxonomies: KizloTaxonomySettings[];
+  crawling: KizloCrawlingSettings;
+  webhook: KizloWebhookSettings;
+  statuses: KizloPostStatus[];
+  plain_permalinks: boolean;
+}
+type KizloSiteSettingsInput = Partial<Omit<KizloSiteSettings, "fallback_image"> & {
+  fallback_image: number | null;
+}>;
+type KizloWebhookSettingsInput = Partial<KizloWebhookSettings>;
+type KizloPersonSettingsInput = Partial<Omit<KizloPersonSettings, "image"> & {
+  image: number | null;
+}>;
+type KizloOrganizationSettingsInput = Partial<Omit<KizloOrganizationSettings, "logo"> & {
+  logo: number | null;
+}>;
+type KizloIdentitySettingsInput = Partial<{
+  type: "person" | "organization";
+  person: KizloPersonSettingsInput | null;
+  organization: KizloOrganizationSettingsInput | null;
+}>;
+type KizloAuthorsSettingsInput = Partial<KizloAuthorsSettings>;
+type KizloCrawlingSettingsInput = Partial<KizloCrawlingSettings>;
+type KizloPostTypeSettingsInput = Partial<Pick<KizloPostTypeSettings, "title_structure" | "description_structure" | "search_engine_visibility" | "webpage_type" | "article_type" | "seo_enabled" | "pathname_structure" | "comment_action_structure" | "rest_api_enabled" | "publicly_queryable">>;
+type KizloTaxonomySettingsInput = Partial<Pick<KizloTaxonomySettings, "title_structure" | "description_structure" | "search_engine_visibility" | "seo_enabled" | "pathname_structure" | "rest_api_enabled" | "publicly_queryable">>;
+//#endregion
+export { KizloAuthorsSettings, KizloAuthorsSettingsInput, KizloCrawlingSettings, KizloCrawlingSettingsInput, KizloIdentitySettings, KizloIdentitySettingsInput, KizloMedia, KizloOrganizationFounder, KizloOrganizationSettings, KizloOrganizationSettingsInput, KizloPersonSettings, KizloPersonSettingsInput, KizloPostStatus, KizloPostTypeSettings, KizloPostTypeSettingsInput, KizloSettings, KizloSiteSettings, KizloSiteSettingsInput, KizloSocialProfile, KizloTaxonomySettings, KizloTaxonomySettingsInput, KizloWebhookSettings, KizloWebhookSettingsInput };

package/dist/settings/service.js

@@ -0,0 +1,43 @@
+import { WP_KIZLO_BASE } from "../wordpress/constants.js";
+
+//#region src/settings/service.ts
+var KizloSettingsService = class {
+	service;
+	constructor(service) {
+		this.service = service;
+	}
+	/** Fetch every Kizlo settings section in one response. */
+	async get() {
+		return this.service.wordpress.get("/settings", { base: WP_KIZLO_BASE });
+	}
+	async updateSite(input) {
+		return this.update("/settings/site", input);
+	}
+	async updateWebhook(input) {
+		return this.update("/settings/webhook", input);
+	}
+	async updateIdentity(input) {
+		return this.update("/settings/identity", input);
+	}
+	async updateAuthors(input) {
+		return this.update("/settings/authors", input);
+	}
+	async updateCrawling(input) {
+		return this.update("/settings/crawling", input);
+	}
+	async updatePostType(slug, input) {
+		return this.update(`/settings/post_types/${slug}`, input);
+	}
+	async updateTaxonomy(slug, input) {
+		return this.update(`/settings/taxonomies/${slug}`, input);
+	}
+	async update(path, body) {
+		return this.service.wordpress.put(path, {
+			base: WP_KIZLO_BASE,
+			body
+		});
+	}
+};
+
+//#endregion
+export { KizloSettingsService };

package/dist/shared/error.d.ts

@@ -88,28 +88,39 @@ type CommonErrorCode = keyof CommonErrorMap;
 type CommonErrorLiteral = LiteralUnion<CommonErrorCode, string>;
 type WithCommonErrorMap<TErrors extends DefinedErrorMapLike> = CommonErrorMap & { [K in keyof TErrors as string extends K ? never : K]: TErrors[K] };
 interface KizloErrorOptions {
+  /** Human-readable message. Defaults to the matching common error's preset message, or the code itself. */
   message?: string;
+  /** HTTP status to send. Defaults to the matching common error's status, or `500`. */
   status?: number;
+  /** Arbitrary payload carried on the error and surfaced to the client. */
   data?: unknown;
+  /** Underlying error that triggered this one; set as the native `Error` `cause`. */
   cause?: unknown;
 }
 declare class KizloError<TCode extends CommonErrorLiteral = CommonErrorLiteral, TData = unknown> extends Error {
+  /** Always `"KizloError"` — the discriminator `isKizloError` checks. */
   readonly name = "KizloError";
+  /** The error code, e.g. `"NOT_FOUND"` or a custom code from your error map. */
   readonly code: TCode;
+  /** The payload passed when the error was thrown, or `null`. */
   readonly data: TData;
+  /** The HTTP status this error maps to. */
   readonly status: number;
   constructor(code: TCode, options?: KizloErrorOptions);
 }
 declare function isKizloError(value: unknown): value is KizloError;
 declare function toKizloError(e: unknown): KizloError;
-type DefinedErrorLike = {
+type ErrorDefinition = {
+  /** HTTP status sent when this error is thrown. Defaults to the matching common error's status, or 500. */
   status?: number;
+  /** Human-readable message. Overridable per throw via `errors.CODE({ message })`. */
   message?: string;
+  /** Standard Schema for the error's `data` payload — validated and typed when you throw `errors.CODE({ data })`. */
   data?: AnySchema;
 };
-declare function defineErrorMap<const T extends Partial<Record<CommonErrorLiteral, DefinedErrorLike>>>(map: T): T;
-type DefinedErrorMapLike = Record<string, DefinedErrorLike>;
-type ThrowableErrorFn<TCode extends string, T extends DefinedErrorLike> = T["data"] extends AnySchema ? undefined extends SchemaInput<T["data"]> ? (options?: {
+declare function defineErrorMap<const T extends Partial<Record<CommonErrorLiteral, ErrorDefinition>>>(map: T): T;
+type DefinedErrorMapLike = Record<string, ErrorDefinition>;
+type ThrowableErrorFn<TCode extends string, T extends ErrorDefinition> = T["data"] extends AnySchema ? undefined extends SchemaInput<T["data"]> ? (options?: {
   status?: number;
   message?: string;
   data?: SchemaInput<T["data"]>;
@@ -125,4 +136,4 @@ type ThrowableErrorFn<TCode extends string, T extends DefinedErrorLike> = T["dat
 type ThrowableErrorMap<T extends DefinedErrorMapLike> = { [K in Extract<keyof T, string>]: ThrowableErrorFn<K, T[K]> };
 declare function createThrowableErrorMap<TError extends DefinedErrorMapLike>(errors: TError): ThrowableErrorMap<WithCommonErrorMap<TError>>;
 //#endregion
-export { COMMON_ERRORS, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, DefinedErrorLike, DefinedErrorMapLike, KizloError, KizloErrorOptions, ThrowableErrorFn, ThrowableErrorMap, WithCommonErrorMap, createThrowableErrorMap, defineErrorMap, isKizloError, toKizloError };
+export { COMMON_ERRORS, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, DefinedErrorMapLike, ErrorDefinition, KizloError, KizloErrorOptions, ThrowableErrorFn, ThrowableErrorMap, WithCommonErrorMap, createThrowableErrorMap, defineErrorMap, isKizloError, toKizloError };

package/dist/shared/error.js

@@ -82,9 +82,13 @@ const COMMON_ERRORS = {
 	}
 };
 var KizloError = class extends Error {
+	/** Always `"KizloError"` — the discriminator `isKizloError` checks. */
 	name = "KizloError";
+	/** The error code, e.g. `"NOT_FOUND"` or a custom code from your error map. */
 	code;
+	/** The payload passed when the error was thrown, or `null`. */
 	data;
+	/** The HTTP status this error maps to. */
 	status;
 	constructor(code, options) {
 		const preset = COMMON_ERRORS[code];

package/dist/shared/extension.d.ts

@@ -9,7 +9,9 @@ interface ExtensionInitOptions {
   };
 }
 interface ExtensionInitResult<TRouter extends AnyProcedureRouter> {
+  /** Procedures the extension exposes, grouped by name. Each entry (or nested group) becomes a client method under the extension's `id`. */
   router?: TRouter;
+  /** Webhook event handlers, built with `createEventHandler`, run when WordPress emits a matching event. */
   events?: EventHandler[];
 }
 interface Extension<TId extends string, TRouter extends AnyProcedureRouter> {

package/dist/shared/middleware.d.ts

@@ -1,29 +1,32 @@
 import { AnyContext } from "./types.js";
-import { DefinedErrorMapLike, ThrowableErrorMap } from "./error.js";
+import { DefinedErrorMapLike } from "./error.js";
 import { ServerContext } from "../context.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;
 interface MiddlewareResult<TOutContext extends AnyContext, TOutput> {
+  /** The handler's return value, as it flows back up through any middleware that awaited `next()`. */
   output: TOutput;
+  /** The context after this point in the chain, including anything middleware added via `next({ context })`. */
   context: TOutContext;
 }
 type MiddlewareNextFn<TOutput> = {
   (): Promise<MiddlewareResult<AnyContext, TOutput>>;
   <UOutContext extends AnyContext>(options: {
+    /** Values to merge into the context for every middleware and the handler downstream — added to it, fully typed. */
     context: UOutContext;
   }): Promise<MiddlewareResult<UOutContext, TOutput>>;
 };
-type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = {
-  input: TInput;
-  context: ServerContext;
+type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = BaseHandlerOptions<TInput, ServerContext, TError> & {
+  /** Run the next middleware (or the handler) and return its result; pass `{ context }` to extend the context for everything downstream. */
   next: MiddlewareNextFn<TOutput>;
-  errors: ThrowableErrorMap<TError>;
 };
-type MiddlewareHandler<TOutContext extends AnyContext, TInput, TOutput, TError extends DefinedErrorMapLike> = (options: MiddlewareOptions<TInput, TOutput, TError>) => Promise<MiddlewareResult<TOutContext, TOutput>>;
-type Middleware<TOutContext extends AnyContext, TInput, TOutput, TError extends DefinedErrorMapLike> = MiddlewareHandler<TOutContext, TInput, TOutput, TError>;
+type MiddlewareHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TOutContext extends AnyContext> = (options: MiddlewareOptions<TInput, TOutput, TError>) => Promise<MiddlewareResult<TOutContext, TOutput>>;
+type Middleware<TInput, TOutput, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TOutContext extends AnyContext = AnyContext> = MiddlewareHandler<TInput, TOutput, TError, TOutContext>;
 type AnyMiddleware = Middleware<any, any, any, any>;
-type ExtractMiddlewareContextOutput<M> = M extends Middleware<infer TOut, any, any, any> ? TOut : never;
-type InferUses<T extends readonly AnyMiddleware[] | undefined> = T extends readonly [] ? object : T extends readonly AnyMiddleware[] ? UnionToIntersection<ExtractMiddlewareContextOutput<T[number]>> : object;
+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 { InferUses };
+export { AnyMiddleware, ExtractMiddlewareContextOutput, InferUses, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, createMiddleware };

package/dist/shared/middleware.js

@@ -0,0 +1,7 @@
+//#region src/shared/middleware.ts
+function createMiddleware(handler) {
+	return handler;
+}
+
+//#endregion
+export { createMiddleware };

package/dist/shared/procedure.d.ts

@@ -1,7 +1,6 @@
-import { AnyContext } from "./types.js";
 import { DefinedErrorMapLike, ThrowableErrorMap, WithCommonErrorMap } from "./error.js";
 import { ServerContext } from "../context.js";
-import { InferUses } from "./middleware.js";
+import { AnyMiddleware, InferUses, Middleware } from "./middleware.js";
 import * as _orpc_contract0 from "@orpc/contract";
 import { AnySchema, DeepMerge, Pathname, Prettify, Promisify, Schema, SchemaInput, SchemaOutput } from "@kizlo/shared";
 import * as _orpc_server0 from "@orpc/server";
@@ -14,33 +13,19 @@ type AnyProcedureRouter = {
 };
 type RouterDepthTuple = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 type ExtractProcedureByScope<TRouter extends AnyProcedureRouter, TScope extends InvocationScope, TDepth extends number = 10> = TDepth extends 0 ? TRouter : { [K in keyof TRouter as TRouter[K] extends Procedure<infer Scope, infer _Input, infer _Output, infer _Errors> ? Scope extends TScope ? K : never : TRouter[K] extends AnyProcedureRouter ? keyof ExtractProcedureByScope<TRouter[K], TScope, RouterDepthTuple[TDepth]> extends never ? never : K : never]: TRouter[K] extends AnyProcedure ? TRouter[K] : TRouter[K] extends AnyProcedureRouter ? ExtractProcedureByScope<TRouter[K], TScope, RouterDepthTuple[TDepth]> : never };
-interface MiddlewareResult<TOutContext extends AnyContext, TOutput> {
-  output: TOutput;
-  context: TOutContext;
-}
-type MiddlewareNextFn<TOutput> = {
-  (): Promise<MiddlewareResult<AnyContext, TOutput>>;
-  <UOutContext extends AnyContext>(options: {
-    context: UOutContext;
-  }): Promise<MiddlewareResult<UOutContext, TOutput>>;
-};
-type MiddlewareOptions<TInput, TOutput, TError extends DefinedErrorMapLike> = {
-  input: TInput;
-  context: ServerContext;
-  next: MiddlewareNextFn<TOutput>;
-  errors: ThrowableErrorMap<TError>;
-};
-type MiddlewareHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TOutContext extends AnyContext> = (options: MiddlewareOptions<TInput, TOutput, TError>) => Promise<MiddlewareResult<TOutContext, TOutput>>;
-type Middleware<TInput, TOutput, TError extends DefinedErrorMapLike = DefinedErrorMapLike, TOutContext extends AnyContext = AnyContext> = MiddlewareHandler<TInput, TOutput, TError, TOutContext>;
-type AnyMiddleware = Middleware<any, any, any, any>;
-type ExtractMiddlewareContextOutput<M> = M extends Middleware<infer TOut, any, any, any> ? 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>;
-type InvocationScope = "internal" | "remote" | "api";
-type ProcedureHandler<TInput, TOutput, TError extends DefinedErrorMapLike, TContext extends ServerContext> = (ctx: {
+/** The base options passed to every procedure handler and middleware. */
+interface BaseHandlerOptions<TInput, TContext, TError extends DefinedErrorMapLike> {
+  /** The validated, typed request. For `api`, the merged `{ params, query, body, headers }`; for `remote`/`internal`, the `input` schema's type. */
   input: TInput;
+  /** Server-side services and adapters — the WordPress client, logger, cookies, auth, and more — plus anything middleware adds. */
   context: TContext;
-  errors: ThrowableErrorMap<WithCommonErrorMap<TError>>;
-}) => Promisify<TOutput>;
+  /** Typed error map — throw `errors.SOME_CODE()` for a known failure. */
+  errors: ProcedureErrors<TError>;
+}
+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>;
 interface Procedure<TScope extends InvocationScope, TInput, TOutput, TError extends DefinedErrorMapLike = DefinedErrorMapLike> {
   "~kizlo": {
     uses: AnyMiddleware[];
@@ -86,23 +71,44 @@ type ResolveOpenapi<TPathname, TBody, TParams, TQuery, THeaders, TMap extends "o
 type ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders> = Prettify<TScope extends "api" ? ResolveOpenapi<TPathname, TBody, TParams, TQuery, THeaders, "output"> : [TInput] extends [Schema] ? SchemaOutput<TInput> : unknown>;
 type ResolvedSchemaInput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders> = Prettify<TScope extends "api" ? ResolveOpenapi<TPathname, TBody, TParams, TQuery, THeaders, "input"> : [TInput] extends [Schema] ? SchemaInput<TInput> : unknown>;
 type ProcedureOptions<TScope extends InvocationScope, TPathname extends Pathname, TInput extends Schema | undefined, TBody extends Schema | undefined, TParams extends Schema | undefined, TQuery extends Schema | undefined, THeaders extends Schema | undefined, TOutput extends Schema, TError extends DefinedErrorMapLike, TMiddlewares extends Middleware<ResolvedSchemaOutput<TScope, TPathname, TInput, TBody, TParams, TQuery, THeaders>, SchemaOutput<TOutput>, TError>[]> = {
+  /** Where the procedure can be called from: `"api"` (HTTP REST endpoint), `"remote"` (RPC-style endpoint), or `"internal"` (server-only). */
   scope: TScope;
+  /** Error codes this procedure can throw, on top of the built-in common HTTP errors. An inline object or a `defineErrorMap`. */
   errors?: TError;
+  /** Schema that types — and, when `outputValidation` is on, validates — the handler's return value. */
   output: TOutput;
+  /** Middleware to run before the handler, in declaration order. */
   middlewares?: TMiddlewares;
+  /**
+   * Validate the incoming request against the input schemas.
+   * @default true
+   */
   inputValidation?: boolean;
+  /**
+   * Validate the return value against `output`.
+   * @default false
+   */
   outputValidation?: boolean;
 } & (TScope extends "api" ? {
+  /** HTTP method for the route, e.g. `"GET"` or `"POST"`. */
   method?: HTTPMethod;
+  /** REST path with `{param}` placeholders, e.g. `/featured/{id}`. */
   path?: TPathname;
+  /** Schema for the request body. */
   body?: TBody;
+  /** Schema for the query string. */
   query?: TQuery;
+  /** Schema for the path parameters. */
   params?: TParams;
+  /** Schema for the request headers. */
   headers?: THeaders;
 } : TScope extends "remote" ? {
+  /** Schema for the call's single input argument. */
   input?: TInput;
+  /** HTTP method for the underlying request. */
   method?: HTTPMethod;
 } : {
+  /** 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>;
@@ -111,4 +117,4 @@ declare function buildProcedure(procedure: AnyProcedure): _orpc_server0.Decorate
 declare function handleUnexpectedError(error: unknown, errors?: DefinedErrorMapLike): never;
 declare function combineDetailed(parts: Record<string, AnySchema>): AnySchema;
 //#endregion
-export { AnyMiddleware, AnyProcedure, AnyProcedureRouter, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, InvocationScope, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, Procedure, ProcedureContext, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createMiddleware, createProcedure, handleUnexpectedError, schemaType };
+export { AnyProcedure, AnyProcedureRouter, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType };

package/dist/shared/procedure.js

@@ -2,9 +2,6 @@ import { COMMON_ERRORS, KizloError, createThrowableErrorMap, isKizloError } from
 import { os } from "@orpc/server";
 
 //#region src/shared/procedure.ts
-function createMiddleware(handler) {
-	return handler;
-}
 function createProcedure(options, handler) {
 	return { "~kizlo": {
 		options,
@@ -92,8 +89,8 @@ function combineDetailed(parts) {
 		version: 1,
 		vendor: "kizlo",
 		validate: async (value) => {
-			if (typeof value !== "object" || value === null) return { issues: [{ message: "Expected object" }] };
-			const input = value;
+			if (value != null && typeof value !== "object") return { issues: [{ message: "Expected object" }] };
+			const input = value ?? {};
 			const result = {};
 			const issues = [];
 			for (const [key, schema] of Object.entries(parts)) {
@@ -111,4 +108,4 @@ function combineDetailed(parts) {
 }
 
 //#endregion
-export { buildProcedure, combineDetailed, createMiddleware, createProcedure, handleUnexpectedError, schemaType };
+export { buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType };

package/dist/shared/types.d.ts

@@ -17,19 +17,25 @@ interface RedirectInput {
   status?: RedirectStatus;
   searchParams?: Record<string, string>;
 }
+type CookiesSetAll = (cookies: CookieWithOptions[]) => Promise<void> | void;
+type CookiesGetAll = () => Promise<{
+  name: string;
+  value: string;
+}[] | null> | {
+  name: string;
+  value: string;
+}[] | null;
+type CookiesDeleteAll = (cookies: {
+  name: string;
+  options?: CookieOptions;
+}[]) => Promise<void> | void;
 interface CookiesAdapter {
-  setAll(cookies: CookieWithOptions[]): Promise<void> | void;
-  getAll(): Promise<{
-    name: string;
-    value: string;
-  }[] | null> | {
-    name: string;
-    value: string;
-  }[] | null;
-  deleteAll(cookies: {
-    name: string;
-    options?: CookieOptions;
-  }[]): Promise<void> | void;
+  /** Write the given cookies, each with its options. */
+  setAll: CookiesSetAll;
+  /** Read all cookies as name/value pairs, or `null` when none are available. */
+  getAll: CookiesGetAll;
+  /** Delete the named cookies, honoring each entry's options (e.g. `path`). */
+  deleteAll: CookiesDeleteAll;
 }
 //#endregion
-export { AnyContext, AnyNestedClient, CookiesAdapter, HTTPMethod, List, MaybeOptionalOptions, RedirectInput, RedirectStatus };
+export { AnyContext, AnyNestedClient, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, HTTPMethod, List, MaybeOptionalOptions, RedirectInput, RedirectStatus };

package/dist/test/client.d.ts

@@ -5,6 +5,11 @@ import "../index.js";
 import { KizloTestInstance } from "./server.js";
 
 //#region src/test/client.d.ts
+/**
+ * Wraps a test instance with the real browser client, routing its requests through the instance's `handler`. Use
+ * it for end-to-end tests: calls go through serialization and the same scope rules as production (internal
+ * procedures never leave the server), returning the `{ success, data, error }` envelope your frontend sees.
+ */
 declare function getKizloClientTestInstance(kizlo: KizloTestInstance): Promise<KizloClient<RootRouter<readonly AnyExtension[]>>>;
 type KizloClientTestInstance = Awaited<ReturnType<typeof getKizloClientTestInstance>>;
 //#endregion

package/dist/test/client.js

@@ -2,6 +2,11 @@ import { generateContract } from "../shared/contract.js";
 import { KizloClient } from "../client.js";
 
 //#region src/test/client.ts
+/**
+* Wraps a test instance with the real browser client, routing its requests through the instance's `handler`. Use
+* it for end-to-end tests: calls go through serialization and the same scope rules as production (internal
+* procedures never leave the server), returning the `{ success, data, error }` envelope your frontend sees.
+*/
 async function getKizloClientTestInstance(kizlo) {
 	return new KizloClient({
 		url: "http://test.local",

package/dist/test/server.d.ts

@@ -2,6 +2,12 @@ import { AnyExtension } from "../shared/extension.js";
 import { Kizlo } from "../kizlo.js";
 
 //#region src/test/server.d.ts
+
+/**
+ * Wires a Kizlo instance against the seeded test stack: admin credentials read from
+ * the test-credentials artifact, with mock geo, auth, and captcha adapters and a
+ * warn/error logger. Call procedures directly through its `client` in integration tests.
+ */
 declare function getKizloTestInstance<TExts extends readonly AnyExtension[] = []>(options?: {
   extensions?: TExts;
 }): Kizlo<TExts>;

package/dist/test/server.js

@@ -7,12 +7,18 @@ import { captchaMock } from "./captcha.js";
 import { toTestUser } from "./users.js";
 
 //#region src/test/server.ts
+/**
+* Wires a Kizlo instance against the seeded test stack: admin credentials read from
+* the test-credentials artifact, with mock geo, auth, and captcha adapters and a
+* warn/error logger. Call procedures directly through its `client` in integration tests.
+*/
 function getKizloTestInstance(options) {
 	const creds = getTestCredentials();
 	return new Kizlo({
 		baseUrl: "http://test.local",
 		siteSecret: "test-secret",
 		environment: "test",
+		target: "production",
 		credentials: {
 			url: creds.url,
 			username: creds.users.admin.username,

package/dist/test.d.ts

@@ -1,6 +1,6 @@
-import { DockerStack, RunResult, Stack, compose, composeDown, composeStop, composeUp, createStack, wpCli } from "./cli/wp/docker.js";
-import { DevPluginSource, Fixture, JsonValue, LocalPlugin, PluginSource, SeedContext, TestAdminUser, TestCredentials, TestUser, defineFixture, isLocalPlugin } from "./cli/wp/types.js";
-import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isSeeded, kizloRelease, resolvePluginSource } from "./cli/wp/utils.js";
+import { DockerStack, RunResult, Stack, compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli } from "./cli/wp/docker.js";
+import { DevPluginSource, Fixture, FixtureCleanupFn, FixtureSeedFn, JsonValue, LocalPlugin, PluginSource, SeedContext, TestAdminUser, TestCredentials, TestUser, defineFixture, isLocalPlugin } from "./cli/wp/types.js";
+import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isSeeded, kizloRelease, recordedPort, resolvePluginSource } from "./cli/wp/utils.js";
 import { TestAuthAdapterUser, toTestUser } from "./test/users.js";
 import { testAuthAdapter } from "./test/auth.js";
 import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
@@ -9,4 +9,4 @@ import { KizloClientTestInstance, getKizloClientTestInstance } from "./test/clie
 import { menuFixture } from "./menu/fixture.js";
 import { postFixture } from "./post/fixture.js";
 import { coreFixtures } from "./test/fixtures.js";
-export { CAPTCHA_TEST_TOKEN_PASS, DevPluginSource, DockerStack, Fixture, JsonValue, KizloClientTestInstance, KizloTestInstance, LocalPlugin, PluginSource, RunResult, SeedContext, Stack, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, activateLocalPlugin, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };
+export { CAPTCHA_TEST_TOKEN_PASS, DevPluginSource, DockerStack, Fixture, FixtureCleanupFn, FixtureSeedFn, JsonValue, KizloClientTestInstance, KizloTestInstance, LocalPlugin, PluginSource, RunResult, SeedContext, Stack, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, activateLocalPlugin, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };

package/dist/test.js

@@ -1,6 +1,6 @@
 import { defineFixture, isLocalPlugin } from "./cli/wp/types.js";
-import { compose, composeDown, composeStop, composeUp, createStack, wpCli } from "./cli/wp/docker.js";
-import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isSeeded, kizloRelease, resolvePluginSource } from "./cli/wp/utils.js";
+import { compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli } from "./cli/wp/docker.js";
+import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isSeeded, kizloRelease, recordedPort, resolvePluginSource } from "./cli/wp/utils.js";
 import { testAuthAdapter } from "./test/auth.js";
 import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
 import { getKizloClientTestInstance } from "./test/client.js";
@@ -10,4 +10,4 @@ import { coreFixtures } from "./test/fixtures.js";
 import { toTestUser } from "./test/users.js";
 import { getKizloTestInstance } from "./test/server.js";
 
-export { CAPTCHA_TEST_TOKEN_PASS, activateLocalPlugin, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };
+export { CAPTCHA_TEST_TOKEN_PASS, activateLocalPlugin, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };

package/dist/webhook/index.d.ts

@@ -1,31 +1,32 @@
-import { WebhookEvent } from "./schema.js";
+import { KizloEvent } from "./schema.js";
 import { DefinedErrorMapLike } from "../shared/error.js";
 import { ServerContext } from "../context.js";
 import { Procedure } from "../shared/procedure.js";
 import "../index.js";
-import { Pathname, Schema, SchemaOutput } from "@kizlo/shared";
+import { Schema, SchemaOutput } from "@kizlo/shared";
 
 //#region src/webhook/index.d.ts
-type AnyWebhookEventSchema<TData = unknown> = Schema<unknown, TData>;
-type AnyWebhookEvents = {
+type AnyEventSchema<TData = unknown> = Schema<unknown, TData>;
+type AnyEvents = {
+  /** Event type strings this entry matches, e.g. `["review.created"]`. The handler's `event.type` is narrowed to this union. */
   types: string[];
-  data: AnyWebhookEventSchema;
+  /** Standard Schema that validates and types each matched event's `data` payload. */
+  data: AnyEventSchema;
 }[];
-type InferWebhookEventUnion<T extends AnyWebhookEvents> = { [K in keyof T]: {
+type InferEventUnion<T extends AnyEvents> = { [K in keyof T]: {
   type: T[K]["types"][number];
   data: SchemaOutput<T[K]["data"]>;
 } }[number];
-type WebhookHandlerFn<T extends AnyWebhookEvents> = (event: InferWebhookEventUnion<T> | WebhookEvent | null, context: ServerContext) => Promise<void> | void;
+type EventHandlerFn<T extends AnyEvents> = (event: InferEventUnion<T> | KizloEvent | null, context: ServerContext) => Promise<void> | void;
 interface WebhookOptions {
-  path?: Pathname;
   events?: EventHandler[];
 }
 interface EventHandler {
-  events?: AnyWebhookEvents;
-  handler: WebhookHandlerFn<AnyWebhookEvents>;
+  events?: AnyEvents;
+  handler: EventHandlerFn<AnyEvents>;
 }
-declare function createEventHandler<const T extends AnyWebhookEvents = never>(handler: WebhookHandlerFn<T>): EventHandler;
-declare function createEventHandler<const T extends AnyWebhookEvents = never>(events: T, handler: WebhookHandlerFn<T>): EventHandler;
+declare function createEventHandler<const T extends AnyEvents = never>(handler: EventHandlerFn<T>): EventHandler;
+declare function createEventHandler<const T extends AnyEvents = never>(events: T, handler: EventHandlerFn<T>): EventHandler;
 declare function createWebhookRouter(options?: WebhookOptions): {
   webhooks: Procedure<"api", {
     body: {
@@ -35,4 +36,4 @@ declare function createWebhookRouter(options?: WebhookOptions): {
   }, unknown, DefinedErrorMapLike>;
 };
 //#endregion
-export { AnyWebhookEventSchema, AnyWebhookEvents, EventHandler, InferWebhookEventUnion, WebhookHandlerFn, WebhookOptions, createEventHandler, createWebhookRouter };
+export { AnyEventSchema, AnyEvents, EventHandler, EventHandlerFn, InferEventUnion, WebhookOptions, createEventHandler, createWebhookRouter };