kizlo 0.15.2 → 0.16.0

package/dist/shared/contract.d.ts

@@ -1,5 +1,5 @@
 import { HTTPMethod } from "./types.js";
-import { AnyProcedureRouter, InvocationScope } from "./procedure.js";
+import { AnyProcedureTree, InvocationScope } from "./procedure.js";
 import { AnyContractRouter } from "@orpc/contract";
 import { Pathname } from "@kizlo/shared";
 
@@ -15,7 +15,7 @@ type ContractProcedure = {
   };
 };
 declare function isContractProcedure$1(node: unknown): node is ContractProcedure;
-declare function generateContract<TRouter extends AnyProcedureRouter>(router: TRouter): Promise<Contract>;
+declare function generateContract<TProcedures extends AnyProcedureTree>(procedures: TProcedures): Promise<Contract>;
 declare function restoreContract(contract: Contract): AnyContractRouter;
 //#endregion
 export { Contract, ContractProcedure, generateContract, isContractProcedure$1 as isContractProcedure, restoreContract };

package/dist/shared/contract.js

@@ -6,8 +6,8 @@ function isContractProcedure$1(node) {
 	if (!node || typeof node !== "object") return false;
 	return "route" in node || "meta" in node;
 }
-async function generateContract(router) {
-	const contract = minifyContractRouter(createOrpcRouter(router));
+async function generateContract(procedures) {
+	const contract = minifyContractRouter(createOrpcRouter(procedures));
 	const walk = (node) => {
 		const out = {};
 		for (const [key, value] of Object.entries(node)) if (isContractProcedure(value)) {

package/dist/shared/integration.d.ts

@@ -0,0 +1,91 @@
+import { ServiceAdapters } from "../adapters/types.js";
+import { EventHandler } from "../webhook/index.js";
+import { AnyProcedureTree } from "./procedure.js";
+import { IntegrationPluginRequirement, UnionToIntersection } from "@kizlo/shared";
+
+//#region src/shared/integration.d.ts
+
+/**
+ * What an integration needs to work at all.
+ *
+ * An integration can ship in two halves that update separately: this package, and the WordPress plugin
+ * that serves the endpoints it calls. Environment values and endpoints are checked when the server starts.
+ * Plugin versions are checked from the headers WordPress returns.
+ */
+interface IntegrationRequirements {
+  /** WordPress plugins serving this integration's endpoints, checked against what the site reports. */
+  plugins?: IntegrationPluginRequirement[];
+  /** Resolved environment values this integration needs, checked after every integration's `env` contribution is composed. */
+  env?: readonly string[];
+  /**
+   * Endpoint subtrees this integration calls, dotted from the root of the generated tree, e.g.
+   * `"woocommerce.store.cart"`. Naming the subtree rather than every leaf keeps this a statement about
+   * which contract has to be present, not a second copy of the call sites.
+   */
+  endpoints?: string[];
+}
+/** Reads a scalar environment value by name. */
+type EnvReader = (name: string) => string | undefined;
+/** A nested environment record. Leaf values are strings supplied by the owning runtime. */
+interface EnvRecord {
+  readonly [name: string]: string | EnvRecord | undefined;
+}
+/** One WordPress connection profile contributed by a runtime integration. */
+interface WordPressEnv extends EnvRecord {
+  readonly siteSecret?: string;
+  readonly wordpressUrl?: string;
+  readonly wordpressUsername?: string;
+  readonly wordpressPassword?: string;
+}
+/**
+ * Runtime-neutral values Kizlo consumes. Runtime integrations map their environment system onto
+ * these camel-case keys. The open string index also lets integrations contribute provider values.
+ */
+interface KizloEnv extends EnvRecord {
+  /** Public URL of the mounted Kizlo handler. */
+  readonly baseUrl?: string;
+  /** WordPress profile to use. Defaults to `remote`. */
+  readonly mode?: string;
+  /** Values used when `mode` is absent or `remote`. */
+  readonly remote?: WordPressEnv;
+  /** Values used when `mode` is `local`. */
+  readonly local?: WordPressEnv;
+}
+/** Environment values an integration contributes, either as a typed record or a lazy reader. */
+type EnvSource = KizloEnv | EnvReader;
+/** Read one scalar value by dotted path from an environment record or reader. */
+declare function readEnv(source: EnvSource, name: string): string | undefined;
+/** Required environment values the composed source does not provide. */
+declare function missingEnv(source: EnvSource, required: readonly string[]): string[];
+interface Integration<TId extends string, TProcedures extends AnyProcedureTree = Record<never, never>> {
+  id: TId;
+  /** Procedures the integration exposes. Each entry or nested group becomes a client method under its `id`. */
+  procedures?: TProcedures;
+  /** Webhook event handlers, built with `createEventHandler`, run when WordPress emits a matching event. */
+  events?: EventHandler[];
+  /** Auth, captcha, geo, logger, or cookies adapters the integration supplies. */
+  adapters?: ServiceAdapters;
+  /** Runtime-neutral environment values the integration contributes. Later concrete values replace earlier ones. */
+  env?: EnvSource;
+  /** Environment, endpoint, and WordPress plugin requirements checked at their documented lifecycle points. */
+  requires?: IntegrationRequirements;
+}
+type AnyIntegration = Integration<any, AnyProcedureTree>;
+type ExtractIntegrationProcedures<TIntegration extends AnyIntegration> = TIntegration extends Integration<infer Name, infer Procedures> ? [keyof Procedures] extends [never] ? never : string extends keyof Procedures ? never : Record<Name, Procedures> : never;
+type InferIntegrationProcedures<TIntegrations extends readonly AnyIntegration[]> = TIntegrations extends readonly [] ? Record<never, never> : ExtractIntegrationProcedures<TIntegrations[number]> extends infer R ? [R] extends [never] ? Record<never, never> : UnionToIntersection<R> : never;
+declare function createIntegration<TId extends string, TProcedures extends AnyProcedureTree = Record<never, never>>(integration: Integration<TId, TProcedures>): Integration<TId, TProcedures>;
+/** The declared subtrees the generated tree does not have. */
+declare function missingEndpoints(endpoints: object, required: readonly string[]): string[];
+/**
+ * Fail at startup when an integration's endpoints are not in the generated tree, naming the plugins that
+ * would have put them there.
+ *
+ * Absent endpoints mean the WordPress half is missing, too old to describe its routes, or the tree was
+ * generated against a different WordPress. Left alone it surfaces as a property access on `undefined`
+ * inside whichever procedure ran first, which says nothing about any of that.
+ */
+declare function assertIntegrationEndpoints(integration: AnyIntegration, endpoints: object): void;
+/** Fail at startup when an integration's required environment values are absent. */
+declare function assertIntegrationEnv(integration: AnyIntegration, env: EnvSource): void;
+//#endregion
+export { AnyIntegration, EnvReader, EnvRecord, EnvSource, ExtractIntegrationProcedures, InferIntegrationProcedures, Integration, IntegrationRequirements, KizloEnv, WordPressEnv, assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv };

package/dist/shared/integration.js

@@ -0,0 +1,59 @@
+import { KizloError } from "./error.js";
+
+//#region src/shared/integration.ts
+/** Read one scalar value by dotted path from an environment record or reader. */
+function readEnv(source, name) {
+	if (typeof source === "function") return source(name);
+	let value = source;
+	for (const segment of name.split(".")) {
+		if (!value || typeof value === "string") return void 0;
+		value = value[segment];
+	}
+	return typeof value === "string" ? value : void 0;
+}
+/** Required environment values the composed source does not provide. */
+function missingEnv(source, required) {
+	return required.filter((name) => !readEnv(source, name)?.trim());
+}
+function createIntegration(integration) {
+	return integration;
+}
+/** The declared subtrees the generated tree does not have. */
+function missingEndpoints(endpoints, required) {
+	return required.filter((path) => {
+		let node = endpoints;
+		for (const key of path.split(".")) {
+			if (node === null || typeof node !== "object" || !(key in node)) return true;
+			node = node[key];
+		}
+		return false;
+	});
+}
+/**
+* Fail at startup when an integration's endpoints are not in the generated tree, naming the plugins that
+* would have put them there.
+*
+* Absent endpoints mean the WordPress half is missing, too old to describe its routes, or the tree was
+* generated against a different WordPress. Left alone it surfaces as a property access on `undefined`
+* inside whichever procedure ran first, which says nothing about any of that.
+*/
+function assertIntegrationEndpoints(integration, endpoints) {
+	const required = integration.requires?.endpoints;
+	if (!required?.length) return;
+	const missing = missingEndpoints(endpoints, required);
+	if (missing.length === 0) return;
+	const plugins = integration.requires?.plugins;
+	const remedy = plugins?.length ? `Install or update the required WordPress plugins (${plugins.map((plugin) => `${plugin.name} ${plugin.version}+`).join(", ")}), then run \`kizlo generate\`.` : "Run `kizlo generate` against a WordPress that serves them.";
+	throw new KizloError("MISSING_WORDPRESS_ENDPOINTS", { message: `The "${integration.id}" integration needs WordPress endpoints your generated client does not have: ${missing.join(", ")}. ${remedy}` });
+}
+/** Fail at startup when an integration's required environment values are absent. */
+function assertIntegrationEnv(integration, env) {
+	const required = integration.requires?.env;
+	if (!required?.length) return;
+	const missing = missingEnv(env, required);
+	if (missing.length === 0) return;
+	throw new KizloError("MISSING_ENV_VALUE", { message: `The "${integration.id}" integration requires environment values that are missing: ${missing.join(", ")}.` });
+}
+
+//#endregion
+export { assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv };

package/dist/shared/procedure.d.ts

@@ -8,18 +8,18 @@ import { HTTPMethod } from "@orpc/server";
 import { JsonifiedValue } from "@orpc/openapi-client";
 
 //#region src/shared/procedure.d.ts
-type AnyProcedureRouter = {
-  [K: string]: AnyProcedure | AnyProcedureRouter;
+type AnyProcedureTree = {
+  [K: string]: AnyProcedure | AnyProcedureTree;
 };
-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 };
+type ProcedureTreeDepthTuple = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+type ExtractProcedureByScope<TProcedures extends AnyProcedureTree, TScope extends InvocationScope, TDepth extends number = 10> = TDepth extends 0 ? TProcedures : { [K in keyof TProcedures as TProcedures[K] extends Procedure<infer Scope, infer _Input, infer _Output, infer _Errors> ? Scope extends TScope ? K : never : TProcedures[K] extends AnyProcedureTree ? keyof ExtractProcedureByScope<TProcedures[K], TScope, ProcedureTreeDepthTuple[TDepth]> extends never ? never : K : never]: TProcedures[K] extends AnyProcedure ? TProcedures[K] : TProcedures[K] extends AnyProcedureTree ? ExtractProcedureByScope<TProcedures[K], TScope, ProcedureTreeDepthTuple[TDepth]> : never };
 /** 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. */
+  /** Server-side services and adapters, including the WordPress client, logger, cookies, and auth, plus anything middleware adds. */
   context: TContext;
-  /** Typed error map — throw `errors.SOME_CODE()` for a known failure. */
+  /** Typed error map. Throw `errors.SOME_CODE()` for a known failure. */
   errors: ProcedureErrors<TError>;
 }
 type InvocationScope = "internal" | "remote" | "api";
@@ -74,7 +74,7 @@ type ProcedureOptions<TScope extends InvocationScope, TPathname extends Pathname
   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. */
+  /** Schema that types the handler's return value and validates it when `outputValidation` is on. */
   output: TOutput;
   /** Middleware to run before the handler, in declaration order. */
   middlewares?: TMiddlewares;
@@ -116,4 +116,4 @@ declare function buildProcedure(procedure: AnyProcedure): _orpc_server0.Decorate
 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, ProcedureErrors, ProcedureHandler, ProcedureOptions, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, RouterDepthTuple, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType };
+export { AnyProcedure, AnyProcedureTree, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureErrors, ProcedureHandler, ProcedureOptions, ProcedureTreeDepthTuple, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType };

package/dist/shared/result.d.ts

@@ -1,5 +1,5 @@
 import { DefinedErrorMapLike, KizloError, WithCommonErrorMap } from "./error.js";
-import { AnyProcedureRouter, Procedure } from "./procedure.js";
+import { AnyProcedureTree, Procedure } from "./procedure.js";
 import { NestedClient } from "@orpc/client";
 import { SchemaOutput } from "@kizlo/shared";
 
@@ -19,6 +19,6 @@ type KizloResult<TOutput, TErrors extends DefinedErrorMapLike = DefinedErrorMapL
   error: KizloErrorUnion<WithCommonErrorMap<TErrors>>;
   success: false;
 };
-type ResultClient<T extends AnyProcedureRouter> = { [K in keyof T]: T[K] extends Procedure<infer _Scope, infer Input, infer Output, infer Errors> ? ProcedureMethod<Input, Output, Errors> : T[K] extends AnyProcedureRouter ? ResultClient<T[K]> : 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 };
 //#endregion
 export { ResultClient };

package/dist/shared/router.d.ts

@@ -1,7 +1,7 @@
-import { AnyProcedureRouter } from "./procedure.js";
+import { AnyProcedureTree } from "./procedure.js";
 import { AnyRouter } from "@orpc/server";
 
 //#region src/shared/router.d.ts
-declare function createOrpcRouter(router: AnyProcedureRouter): AnyRouter;
+declare function createOrpcRouter(procedures: AnyProcedureTree): AnyRouter;
 //#endregion
 export { createOrpcRouter };

package/dist/shared/router.js

@@ -1,9 +1,9 @@
 import { buildProcedure } from "./procedure.js";
 
 //#region src/shared/router.ts
-function createOrpcRouter(router) {
+function createOrpcRouter(procedures) {
 	const cache = /* @__PURE__ */ new Map();
-	return new Proxy(router, { get: (target, p) => {
+	return new Proxy(procedures, { get: (target, p) => {
 		if (typeof p === "symbol") return target[p];
 		if (cache.has(p)) return cache.get(p);
 		const value = target[p];

package/dist/tag/index.js

@@ -7,7 +7,7 @@ import { deserializeTag } from "./utils.js";
 import { normalizeArrayableValue } from "@kizlo/shared";
 
 //#region src/tag/index.ts
-const TAG_ROUTER_MAP = {
+const TAG_PROCEDURES = {
 	get: createProcedure({
 		scope: "api",
 		method: "GET",
@@ -73,4 +73,4 @@ const TAG_ROUTER_MAP = {
 };
 
 //#endregion
-export { TAG_ROUTER_MAP };
+export { TAG_PROCEDURES };

package/dist/tanstack-start/server.d.ts

@@ -3,9 +3,9 @@ import { renderJsonLd } from "../seo/utils.js";
 import { LinkDescriptor, MetaDescriptor, RouteHead, ScriptDescriptor, resolvePageHead } from "../integrations/tanstack-start/metadata.js";
 import { ServerRoute, ServerRouteContext, getServerBaseUrl } from "../integrations/tanstack-start/utils.js";
 import { ApiHandlers, KizloHandler, createApiHandlers } from "../integrations/tanstack-start/api.js";
-import { KizloServerOptions, createKizlo } from "../integrations/tanstack-start/kizlo.server.js";
+import { TanstackStartOptions, tanstackStart } from "../integrations/tanstack-start/integration.js";
 import { createManifestRoute } from "../integrations/tanstack-start/manifest.js";
 import { createRobotsRoute } from "../integrations/tanstack-start/robots.js";
 import { resolveRootHead } from "../integrations/tanstack-start/root-head.js";
 import { createSitemapRedirectRoute, createSitemapRoute } from "../integrations/tanstack-start/sitemap.js";
-export { ApiHandlers, KizloHandler, KizloServerOptions, LinkDescriptor, MetaDescriptor, RouteHead, ScriptDescriptor, ServerRoute, ServerRouteContext, WEB_MANIFEST_ROUTE, createApiHandlers, createKizlo, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead };
+export { ApiHandlers, KizloHandler, LinkDescriptor, MetaDescriptor, RouteHead, ScriptDescriptor, ServerRoute, ServerRouteContext, TanstackStartOptions, WEB_MANIFEST_ROUTE, createApiHandlers, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead, tanstackStart };

package/dist/tanstack-start/server.js

@@ -3,10 +3,10 @@ import { renderJsonLd } from "../seo/utils.js";
 import { getServerBaseUrl } from "../integrations/tanstack-start/utils.js";
 import { resolvePageHead } from "../integrations/tanstack-start/metadata.js";
 import { createApiHandlers } from "../integrations/tanstack-start/api.js";
-import { createKizlo } from "../integrations/tanstack-start/kizlo.server.js";
+import { tanstackStart } from "../integrations/tanstack-start/integration.js";
 import { createManifestRoute } from "../integrations/tanstack-start/manifest.js";
 import { createRobotsRoute } from "../integrations/tanstack-start/robots.js";
 import { resolveRootHead } from "../integrations/tanstack-start/root-head.js";
 import { createSitemapRedirectRoute, createSitemapRoute } from "../integrations/tanstack-start/sitemap.js";
 
-export { WEB_MANIFEST_ROUTE, createApiHandlers, createKizlo, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead };
+export { WEB_MANIFEST_ROUTE, createApiHandlers, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead, tanstackStart };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizlo",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "type": "module",
   "description": "A headless WordPress framework for TypeScript.",
   "keywords": [
@@ -52,6 +52,12 @@
         "default": "./dist/test.js"
       }
     },
+    "./node": {
+      "import": {
+        "types": "./dist/node.d.ts",
+        "default": "./dist/node.js"
+      }
+    },
     "./nextjs": {
       "import": {
         "types": "./dist/nextjs.d.ts",
@@ -100,7 +106,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.5.1",
-    "@kizlo/shared": "0.7.0",
+    "@kizlo/shared": "0.8.0",
     "@orpc/client": "^1.14.3",
     "@orpc/contract": "^1.14.3",
     "@orpc/openapi": "^1.14.3",

package/dist/integrations/astro/kizlo.server.d.ts

@@ -1,10 +0,0 @@
-import { AnyExtension } from "../../shared/extension.js";
-import { CreateKizloOptions, EnvReader, Kizlo } from "../../kizlo.js";
-
-//#region src/integrations/astro/kizlo.server.d.ts
-type KizloServerOptions<TExts extends readonly AnyExtension[] = []> = CreateKizloOptions<TExts> & {
-  getSecret: EnvReader;
-};
-declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options: KizloServerOptions<TExts>): Kizlo<TExts>;
-//#endregion
-export { KizloServerOptions, createKizlo };

package/dist/integrations/astro/kizlo.server.js

@@ -1,12 +0,0 @@
-import { Kizlo, resolveKizloConfig } from "../../kizlo.js";
-
-//#region src/integrations/astro/kizlo.server.ts
-function createKizlo(options) {
-	return new Kizlo(resolveKizloConfig(options, {
-		baseUrlEnvKey: "PUBLIC_KIZLO_API_URL",
-		env: options?.getSecret
-	}));
-}
-
-//#endregion
-export { createKizlo };

package/dist/integrations/nextjs/kizlo.server.d.ts

@@ -1,11 +0,0 @@
-import { AnyExtension } from "../../shared/extension.js";
-import { CreateKizloOptions, Kizlo } from "../../kizlo.js";
-import { NextRevalidateOptions } from "./revalidate.js";
-
-//#region src/integrations/nextjs/kizlo.server.d.ts
-type KizloServerOptions<TExts extends readonly AnyExtension[] = []> = CreateKizloOptions<TExts> & {
-  revalidate?: boolean | NextRevalidateOptions;
-};
-declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options?: KizloServerOptions<TExts>): Kizlo<TExts>;
-//#endregion
-export { KizloServerOptions, createKizlo };

package/dist/integrations/nextjs/kizlo.server.js

@@ -1,15 +0,0 @@
-import { Kizlo, resolveKizloConfig } from "../../kizlo.js";
-import { nextRevalidation } from "./revalidate.js";
-
-//#region src/integrations/nextjs/kizlo.server.ts
-function createKizlo(options) {
-	const revalidate = options?.revalidate;
-	const extensions = [...revalidate === false ? [] : [nextRevalidation(typeof revalidate === "object" ? revalidate : void 0)], ...options?.extensions ?? []];
-	return new Kizlo(resolveKizloConfig({
-		...options,
-		extensions
-	}, { baseUrlEnvKey: "NEXT_PUBLIC_KIZLO_API_URL" }));
-}
-
-//#endregion
-export { createKizlo };

package/dist/integrations/tanstack-start/kizlo.server.d.ts

@@ -1,14 +0,0 @@
-import { AnyExtension } from "../../shared/extension.js";
-import { CreateKizloOptions, Kizlo } from "../../kizlo.js";
-
-//#region src/integrations/tanstack-start/kizlo.server.d.ts
-type KizloServerOptions<TExts extends readonly AnyExtension[] = []> = CreateKizloOptions<TExts>;
-/**
- * The server-to-server Kizlo instance for a TanStack Start app. Reads env through `process.env` (the
- * Nitro/Node server runtime TanStack Start builds on), resolving the public API base URL from
- * `VITE_KIZLO_API_URL`. Used only server-side — server routes and server functions — so it never
- * reaches the browser bundle.
- */
-declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options?: KizloServerOptions<TExts>): Kizlo<TExts>;
-//#endregion
-export { KizloServerOptions, createKizlo };

package/dist/integrations/tanstack-start/kizlo.server.js

@@ -1,15 +0,0 @@
-import { Kizlo, resolveKizloConfig } from "../../kizlo.js";
-
-//#region src/integrations/tanstack-start/kizlo.server.ts
-/**
-* The server-to-server Kizlo instance for a TanStack Start app. Reads env through `process.env` (the
-* Nitro/Node server runtime TanStack Start builds on), resolving the public API base URL from
-* `VITE_KIZLO_API_URL`. Used only server-side — server routes and server functions — so it never
-* reaches the browser bundle.
-*/
-function createKizlo(options) {
-	return new Kizlo(resolveKizloConfig(options, { baseUrlEnvKey: "VITE_KIZLO_API_URL" }));
-}
-
-//#endregion
-export { createKizlo };

package/dist/router.js

@@ -1,23 +0,0 @@
-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,
-	settings: SETTINGS_ROUTER_MAP
-};
-
-//#endregion
-export { ROUTER_MAP };

package/dist/shared/extension.d.ts

@@ -1,58 +0,0 @@
-import { EventHandler } from "../webhook/index.js";
-import { AnyProcedureRouter } from "./procedure.js";
-import { ExtensionPluginRequirement, UnionToIntersection } from "@kizlo/shared";
-
-//#region src/shared/extension.d.ts
-interface ExtensionInitOptions {
-  context: {
-    something: string;
-  };
-}
-/**
- * What an extension needs from WordPress to work at all.
- *
- * An extension ships in two halves that update separately: this package, and the WordPress plugin that
- * serves the endpoints it calls. Neither half can see the other's version through npm, so an extension
- * says here what it is calling, and Kizlo checks it once at startup rather than letting the first
- * request fail somewhere inside a procedure.
- */
-interface ExtensionRequirements {
-  /** The WordPress plugin serving this extension's endpoints, checked against what the site reports. */
-  plugin?: ExtensionPluginRequirement;
-  /**
-   * Endpoint subtrees this extension calls, dotted from the root of the generated tree, e.g.
-   * `"woocommerce.store.cart"`. Naming the subtree rather than every leaf keeps this a statement about
-   * which contract has to be present, not a second copy of the call sites.
-   */
-  endpoints?: string[];
-}
-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> {
-  id: TId;
-  init: ExtensionInitFn<TRouter>;
-  /** What this extension needs from WordPress. Checked when the server is created. */
-  requires?: ExtensionRequirements;
-}
-type AnyExtension = Extension<any, AnyProcedureRouter>;
-type ExtensionInitFn<TRouter extends AnyProcedureRouter> = (context: ExtensionInitOptions) => ExtensionInitResult<TRouter>;
-type ExtractExtensionRouter<TExt extends AnyExtension> = TExt extends Extension<infer Name, infer Router> ? [keyof Router] extends [never] ? never : string extends keyof Router ? never : Record<Name, Router> : never;
-type InferExtensionRouter<TExt extends readonly AnyExtension[]> = TExt extends readonly [] ? Record<never, never> : ExtractExtensionRouter<TExt[number]> extends infer R ? [R] extends [never] ? Record<never, never> : UnionToIntersection<R> : never;
-declare function createExtension<TId extends string, TRouter extends AnyProcedureRouter = AnyProcedureRouter>(extension: Extension<TId, TRouter>): Extension<TId, TRouter>;
-/** The declared subtrees the generated tree does not have. */
-declare function missingEndpoints(endpoints: object, required: readonly string[]): string[];
-/**
- * Fail at startup when an extension's endpoints are not in the generated tree, naming the plugin that
- * would have put them there.
- *
- * Absent endpoints mean the WordPress half is missing, too old to describe its routes, or the tree was
- * generated against a different WordPress. Left alone it surfaces as a property access on `undefined`
- * inside whichever procedure ran first, which says nothing about any of that.
- */
-declare function assertExtensionEndpoints(extension: AnyExtension, endpoints: object): void;
-//#endregion
-export { AnyExtension, Extension, ExtensionInitFn, ExtensionInitOptions, ExtensionInitResult, ExtensionRequirements, ExtractExtensionRouter, InferExtensionRouter, assertExtensionEndpoints, createExtension, missingEndpoints };

package/dist/shared/extension.js

@@ -1,37 +0,0 @@
-import { KizloError } from "./error.js";
-
-//#region src/shared/extension.ts
-function createExtension(extension) {
-	return extension;
-}
-/** The declared subtrees the generated tree does not have. */
-function missingEndpoints(endpoints, required) {
-	return required.filter((path) => {
-		let node = endpoints;
-		for (const key of path.split(".")) {
-			if (node === null || typeof node !== "object" || !(key in node)) return true;
-			node = node[key];
-		}
-		return false;
-	});
-}
-/**
-* Fail at startup when an extension's endpoints are not in the generated tree, naming the plugin that
-* would have put them there.
-*
-* Absent endpoints mean the WordPress half is missing, too old to describe its routes, or the tree was
-* generated against a different WordPress. Left alone it surfaces as a property access on `undefined`
-* inside whichever procedure ran first, which says nothing about any of that.
-*/
-function assertExtensionEndpoints(extension, endpoints) {
-	const required = extension.requires?.endpoints;
-	if (!required?.length) return;
-	const missing = missingEndpoints(endpoints, required);
-	if (missing.length === 0) return;
-	const plugin = extension.requires?.plugin;
-	const remedy = plugin ? `Install or update the ${plugin.name} WordPress plugin (${plugin.version}+), then run \`kizlo generate\`.` : "Run `kizlo generate` against a WordPress that serves them.";
-	throw new KizloError("MISSING_WORDPRESS_ENDPOINTS", { message: `The "${extension.id}" extension needs WordPress endpoints your generated client does not have: ${missing.join(", ")}. ${remedy}` });
-}
-
-//#endregion
-export { assertExtensionEndpoints, createExtension, missingEndpoints };