kizlo 0.15.2 → 0.17.0

package/dist/integrations/tanstack-start/utils.js

@@ -3,13 +3,13 @@ import { KizloError } from "../../shared/error.js";
 //#region src/integrations/tanstack-start/utils.ts
 /**
 * The public Kizlo API base URL, read from `process.env` as a last-resort fallback for a client built
-* without an explicit `url`. Client-side code passes `import.meta.env.VITE_KIZLO_API_URL` at the call
+* without an explicit `url`. Client-side code passes `import.meta.env.VITE_KIZLO_BASE_URL` at the call
 * site (see the template's `client.ts`) so Vite inlines it into the browser bundle; this fallback only
 * matters when neither is supplied.
 */
 function getServerBaseUrl() {
-	const baseUrl = process.env.VITE_KIZLO_API_URL?.trim();
-	if (!baseUrl) throw new KizloError("MISSING_ENV_VARIABLE", { message: "Please define VITE_KIZLO_API_URL in your .env file." });
+	const baseUrl = process.env.VITE_KIZLO_BASE_URL?.trim();
+	if (!baseUrl) throw new KizloError("MISSING_ENV_VARIABLE", { message: "Please define VITE_KIZLO_BASE_URL in your .env file." });
 	return baseUrl;
 }
 

package/dist/kizlo.d.ts

@@ -1,77 +1,49 @@
 import { WordPressCredentials } from "./wordpress/types.js";
 import "./wordpress/index.js";
-import { AuthAdapter } from "./adapters/auth.js";
-import { CaptchaAdapter } from "./adapters/captcha.js";
-import { CookiesAdapter } from "./shared/types.js";
-import { GeoAdapter } from "./adapters/geo.js";
-import { Environment, LoggerAdapter } from "./adapters/logger.js";
+import { LogLevel } from "./adapters/logger.js";
 import { Context } from "./context.js";
-import { RouterMap } from "./router.js";
-import { AnyExtension, InferExtensionRouter } from "./shared/extension.js";
+import { CoreProcedures } from "./procedures.js";
+import { AnyIntegration, EnvReader, InferIntegrationProcedures } from "./shared/integration.js";
 import { ResultClient } from "./shared/result.js";
 
 //#region src/kizlo.d.ts
 type AnyKizloConfig = KizloConfig<any>;
-/**
- * Which credential set to read from the environment. Independent of `environment`
- * (which carries logging semantics off `NODE_ENV`): `"local"` reads the `KIZLO_LOCAL_WP_*`
- * / `KIZLO_LOCAL_WP_SECRET` keys local WordPress manages, `"remote"` reads `KIZLO_WP_*` / `KIZLO_WP_SECRET`.
- */
-type KizloConnect = "local" | "remote";
-interface KizloConfig<TExts extends readonly AnyExtension[]> {
+interface KizloConfig<TIntegrations extends readonly AnyIntegration[]> {
   baseUrl: string;
   siteSecret: string;
-  extensions?: TExts;
-  environment: Environment;
-  connect: KizloConnect;
-  adapters?: ServiceAdapters;
+  integrations?: TIntegrations;
+  logging?: false | LogLevel;
   credentials: WordPressCredentials;
   wordpressEndpoints?: object;
 }
-interface ServiceAdapters {
-  geo?: GeoAdapter;
-  auth?: AuthAdapter;
-  logger?: LoggerAdapter;
-  captcha?: CaptchaAdapter;
-  cookies?: CookiesAdapter;
-}
-type RootRouter<TExts extends readonly AnyExtension[]> = InferExtensionRouter<TExts> & RouterMap;
-type S2SClient<TExts extends readonly AnyExtension[]> = ResultClient<RootRouter<TExts>>;
-declare class Kizlo<TExts extends readonly AnyExtension[] = []> {
+type RootProcedures<TIntegrations extends readonly AnyIntegration[]> = InferIntegrationProcedures<TIntegrations> & CoreProcedures;
+type S2SClient<TIntegrations extends readonly AnyIntegration[]> = ResultClient<RootProcedures<TIntegrations>>;
+declare class Kizlo<TIntegrations extends readonly AnyIntegration[] = []> {
   readonly context: Context;
-  readonly client: S2SClient<TExts>;
-  readonly router: RootRouter<TExts>;
+  readonly client: S2SClient<TIntegrations>;
+  readonly procedures: RootProcedures<TIntegrations>;
   private readonly remoteHandler;
   private readonly openapiHandler;
   private readonly config;
-  constructor(config: KizloConfig<TExts>);
+  constructor(config: KizloConfig<TIntegrations>);
   handler(request: Request): Promise<Response>;
   private errorInterceptor;
   private checkInvocationScope;
-  private registerExtensions;
+  private registerIntegrations;
 }
-interface CreateKizloOptions<TExts extends readonly AnyExtension[] = []> {
-  /** Public base URL of your Kizlo server, used to route requests. Falls back to the `KIZLO_API_URL` env var. */
+interface CreateKizloOptions<TIntegrations extends readonly AnyIntegration[] = []> {
+  /** Public base URL of your Kizlo server. Falls back to the `baseUrl` value contributed by an integration. */
   baseUrl?: string;
-  /** Secret shared with the WordPress plugin to sign and verify webhooks. Falls back to the `KIZLO_WP_SECRET` env var (connect-selected). */
+  /** Secret shared with WordPress. Falls back to the `siteSecret` value contributed by an integration. */
   siteSecret?: string;
-  /** Extensions to register, built with `createExtension` — mounts their namespaces on the client and their routes and event handlers on the handler. */
-  extensions?: TExts;
-  /** Runtime environment. Falls back to `NODE_ENV`, then `"development"`. */
-  environment?: Environment;
-  /**
-   * Which credential set to use. Falls back to the `KIZLO_CONNECT` env var, then `"remote"`.
-   * Independent of `environment`: `"local"` reads `KIZLO_LOCAL_WP_*` / `KIZLO_LOCAL_WP_SECRET` (the keys
-   * local WordPress manages), `"remote"` reads `KIZLO_WP_*` / `KIZLO_WP_SECRET`.
-   */
-  connect?: KizloConnect;
-  /** Service adapters: auth, captcha, geo, logger, and cookies. */
-  adapters?: ServiceAdapters;
+  /** Integrations to compose, built with `createIntegration`. */
+  integrations?: TIntegrations;
+  /** Enable Kizlo's built-in console logger at this level. */
+  logging?: false | LogLevel;
   /**
-   * The generated endpoints to run against WordPress, plus the connection to run them on. Pass the
-   * `endpoints` export of your generated barrel. Each credential falls back to a connect-selected
-   * env var: with the default `"remote"` connect to `KIZLO_WP_URL` / `KIZLO_WP_USERNAME` /
-   * `KIZLO_WP_APP_PASSWORD`, and with the `"local"` connect to their `KIZLO_LOCAL_WP_*` counterparts.
+   * The generated endpoints to run against WordPress, plus optional explicit credentials. Pass the
+   * `endpoints` export of your generated barrel. Missing credentials fall back to the `wordpressUrl`,
+   * `wordpressUsername`, and `wordpressPassword` values contributed by integrations.
    */
   wordpress?: {
     endpoints?: object;
@@ -79,30 +51,21 @@ interface CreateKizloOptions<TExts extends readonly AnyExtension[] = []> {
   };
 }
 /**
- * Reads a single environment variable by name. Defaults to `process.env`, but framework factories can
- * pass their own source: the Astro factory hands in `getSecret` from `astro:env/server`, so `.env` is
- * resolved the Astro-native way (through the dev server / adapter) rather than through `process.env`.
+ * Compose environment sources without letting `undefined` erase an earlier value, then resolve
+ * Kizlo's active WordPress connection from the canonical `mode` value.
  */
-type EnvReader = (name: string) => string | undefined;
-declare function resolveWordPressConnection(options: Pick<CreateKizloOptions, "connect" | "wordpress"> | undefined, env?: EnvReader): {
-  connect: KizloConnect;
+declare function integrationEnv(integrations: readonly AnyIntegration[]): EnvReader;
+declare function resolveWordPressConnection(options: Pick<CreateKizloOptions, "wordpress"> | undefined, env: EnvReader): {
   credentials: WordPressCredentials;
 };
 /**
- * Resolves a full `KizloConfig` from options and the environment. Shared by the
- * base `createKizlo` and each framework factory — the single place env values
- * and credentials are read. `baseUrlEnvKey` is the only framework-varying part.
+ * Resolves a full `KizloConfig` from explicit options and the composed integration environment.
  */
-declare function resolveKizloConfig<TExts extends readonly AnyExtension[]>(options: CreateKizloOptions<TExts> | undefined, defaults: {
-  baseUrlEnvKey: string;
-  adapters?: ServiceAdapters;
-  env?: EnvReader;
-}): KizloConfig<TExts>;
+declare function resolveKizloConfig<TIntegrations extends readonly AnyIntegration[]>(options: CreateKizloOptions<TIntegrations> | undefined): KizloConfig<TIntegrations>;
 /**
- * Creates a Kizlo server from the environment (`KIZLO_API_URL`, `KIZLO_WP_SECRET`,
- * `KIZLO_WP_*`), with options taking precedence. Framework packages wrap this
- * with their own URL convention and adapters.
+ * Creates a Kizlo server from integration-contributed environment values, with explicit options
+ * taking precedence.
  */
-declare function createKizlo<TExts extends readonly AnyExtension[] = []>(options?: CreateKizloOptions<TExts>): Kizlo<TExts>;
+declare function createKizlo<TIntegrations extends readonly AnyIntegration[] = []>(options?: CreateKizloOptions<TIntegrations>): Kizlo<TIntegrations>;
 //#endregion
-export { AnyKizloConfig, CreateKizloOptions, EnvReader, Kizlo, KizloConfig, KizloConnect, RootRouter, S2SClient, ServiceAdapters, createKizlo, resolveKizloConfig, resolveWordPressConnection };
+export { AnyKizloConfig, CreateKizloOptions, Kizlo, KizloConfig, RootProcedures, S2SClient, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection };

package/dist/kizlo.js

@@ -1,11 +1,14 @@
-import { CONTRACT_GENERATION_ENV, RPC_PROTOCOL_HEADER } from "./shared/constants.js";
+import { consoleLog } from "./adapters/logger.js";
+import { mergeServiceAdapters } from "./adapters/types.js";
+import { RPC_PROTOCOL_HEADER } from "./shared/constants.js";
 import { KizloError } from "./shared/error.js";
 import { createOrpcRouter } from "./shared/router.js";
 import { createResultClient } from "./shared/result.js";
 import { isTypescriptObject } from "./shared/utils.js";
 import { Context } from "./context.js";
-import { ROUTER_MAP } from "./router.js";
-import { assertExtensionEndpoints } from "./shared/extension.js";
+import { CORE_PROCEDURES } from "./procedures.js";
+import { isContractGeneration } from "./shared/contract-generation.js";
+import { assertIntegrationEndpoints, assertIntegrationEnv, readEnv } from "./shared/integration.js";
 import { createWebhookRouter } from "./webhook/index.js";
 import { tryCatch } from "@kizlo/shared";
 import { ORPCError, createRouterClient } from "@orpc/server";
@@ -16,25 +19,25 @@ import { RPCHandler } from "@orpc/server/fetch";
 var Kizlo = class {
 	context;
 	client;
-	router;
+	procedures;
 	remoteHandler;
 	openapiHandler;
 	config;
 	constructor(config) {
 		this.config = config;
-		const extensions = this.registerExtensions();
+		const integrations = this.registerIntegrations();
 		this.context = new Context({
-			adapters: config.adapters,
+			adapters: integrations.adapters,
 			siteSecret: config.siteSecret,
 			credentials: config.credentials,
 			wordpressEndpoints: config.wordpressEndpoints,
-			extensionPlugins: extensions.plugins
+			integrationPlugins: integrations.plugins
 		});
-		this.router = Object.assign(Object.assign({}, {
-			...extensions.router,
-			...ROUTER_MAP
-		}), { webhooks: createWebhookRouter({ events: extensions.events }) });
-		const orpcRouter = createOrpcRouter(this.router);
+		this.procedures = Object.assign(Object.assign({}, {
+			...integrations.procedures,
+			...CORE_PROCEDURES
+		}), { webhooks: createWebhookRouter({ events: integrations.events }) });
+		const orpcRouter = createOrpcRouter(this.procedures);
 		this.client = createResultClient(createRouterClient(orpcRouter, { context: () => this.context.createServerContext() }));
 		this.remoteHandler = new RPCHandler(orpcRouter, {
 			filter: (options) => {
@@ -90,93 +93,106 @@ var Kizlo = class {
 	checkInvocationScope(value, scope) {
 		return isTypescriptObject(value) && "scope" in value && value.scope === scope;
 	}
-	registerExtensions() {
-		const router = {};
+	registerIntegrations() {
+		const procedures = {};
 		const events = [];
 		const plugins = [];
-		const generating = Boolean(process.env[CONTRACT_GENERATION_ENV]);
-		for (const extension of this.config.extensions ?? []) {
-			if (!generating) assertExtensionEndpoints(extension, this.config.wordpressEndpoints ?? {});
-			if (extension.requires?.plugin) plugins.push(extension.requires.plugin);
-			const data = extension.init({ context: { something: "" } });
-			if (data.router) router[extension.id] = data.router;
-			for (const handler of data.events ?? []) events.push(handler);
+		let adapters = mergeServiceAdapters(this.config.logging ? { logger: consoleLog({ levels: levelsFrom(this.config.logging) }) } : void 0);
+		const reservedIds = new Set([...Object.keys(CORE_PROCEDURES), "webhooks"]);
+		const integrationIds = /* @__PURE__ */ new Set();
+		const generating = isContractGeneration();
+		for (const integration of this.config.integrations ?? []) {
+			if (reservedIds.has(integration.id)) throw new KizloError("INTEGRATION_ID_CONFLICT", { message: `The integration id "${integration.id}" is reserved by Kizlo. Choose a different integration id.` });
+			if (integrationIds.has(integration.id)) throw new KizloError("INTEGRATION_ID_CONFLICT", { message: `The integration id "${integration.id}" is registered more than once. Give every integration a unique id.` });
+			integrationIds.add(integration.id);
+			if (!generating) assertIntegrationEndpoints(integration, this.config.wordpressEndpoints ?? {});
+			plugins.push(...integration.requires?.plugins ?? []);
+			if (integration.procedures && Object.keys(integration.procedures).length > 0) procedures[integration.id] = integration.procedures;
+			for (const handler of integration.events ?? []) events.push(handler);
+			adapters = mergeServiceAdapters(adapters, integration.adapters);
 		}
 		return {
+			adapters,
 			events,
 			plugins,
-			router
+			procedures
 		};
 	}
 };
-const processEnvReader = (name) => process.env[name];
-function requireEnv(name, env) {
-	const value = env(name)?.trim();
-	if (value) return value;
-	if (process.env[CONTRACT_GENERATION_ENV]) return "";
-	throw new KizloError("MISSING_ENV_VARIABLE", { message: `Please define ${name} in your .env file.` });
+const WORDPRESS_ENV_VALUES = new Set([
+	"siteSecret",
+	"wordpressUrl",
+	"wordpressUsername",
+	"wordpressPassword"
+]);
+/**
+* Compose environment sources without letting `undefined` erase an earlier value, then resolve
+* Kizlo's active WordPress connection from the canonical `mode` value.
+*/
+function integrationEnv(integrations) {
+	const composed = (name) => {
+		let value;
+		for (const integration of integrations) {
+			if (!integration.env) continue;
+			const contribution = readEnv(integration.env, name);
+			if (contribution !== void 0) value = contribution;
+		}
+		return value;
+	};
+	const mode = composed("mode")?.trim();
+	if (mode && mode !== "local" && mode !== "remote") throw new KizloError("INVALID_ENV_VALUE", { message: `The "mode" environment value must be "local" or "remote", got "${mode}".` });
+	const profile = mode === "local" ? "local" : "remote";
+	return (name) => {
+		return WORDPRESS_ENV_VALUES.has(name) ? composed(`${profile}.${name}`) : composed(name);
+	};
 }
-function resolveConnect(option, env) {
-	if (option) return option;
-	const value = env("KIZLO_CONNECT")?.trim();
-	if (!value) return "remote";
-	if (value !== "local" && value !== "remote") throw new KizloError("INVALID_ENV_VARIABLE", { message: `KIZLO_CONNECT must be "local" or "remote", got "${value}".` });
-	return value;
+function levelsFrom(level) {
+	const levels = [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	];
+	return levels.slice(levels.indexOf(level));
 }
-/** Env var names for a credential set: `KIZLO_LOCAL_WP_URL` / `KIZLO_LOCAL_WP_SECRET` for local, `KIZLO_WP_URL` / `KIZLO_WP_SECRET` for remote. */
-function connectEnvKeys(connect) {
-	const prefix = connect === "local" ? "KIZLO_LOCAL_" : "KIZLO_";
-	return {
-		siteSecret: `${prefix}WP_SECRET`,
-		url: `${prefix}WP_URL`,
-		username: `${prefix}WP_USERNAME`,
-		password: `${prefix}WP_APP_PASSWORD`
-	};
+function requireEnvValue(name, env) {
+	const value = env(name)?.trim();
+	if (value) return value;
+	if (isContractGeneration()) return "";
+	throw new KizloError("MISSING_ENV_VALUE", { message: `Kizlo requires the "${name}" environment value. Provide it through an integration or an explicit createKizlo option.` });
 }
-function resolveWordPressConnection(options, env = processEnvReader) {
+function resolveWordPressConnection(options, env) {
 	const credentials = options?.wordpress?.credentials;
-	const connect = resolveConnect(options?.connect, env);
-	const keys = connectEnvKeys(connect);
-	return {
-		connect,
-		credentials: {
-			url: credentials?.url ?? requireEnv(keys.url, env),
-			username: credentials?.username ?? requireEnv(keys.username, env),
-			password: credentials?.password ?? requireEnv(keys.password, env)
-		}
-	};
+	return { credentials: {
+		url: credentials?.url ?? requireEnvValue("wordpressUrl", env),
+		username: credentials?.username ?? requireEnvValue("wordpressUsername", env),
+		password: credentials?.password ?? requireEnvValue("wordpressPassword", env)
+	} };
 }
 /**
-* Resolves a full `KizloConfig` from options and the environment. Shared by the
-* base `createKizlo` and each framework factory — the single place env values
-* and credentials are read. `baseUrlEnvKey` is the only framework-varying part.
+* Resolves a full `KizloConfig` from explicit options and the composed integration environment.
 */
-function resolveKizloConfig(options, defaults) {
-	const env = defaults.env ?? processEnvReader;
-	const { connect, credentials } = resolveWordPressConnection(options, env);
-	const keys = connectEnvKeys(connect);
+function resolveKizloConfig(options) {
+	const integrations = options?.integrations ?? [];
+	const env = integrationEnv(integrations);
+	if (!isContractGeneration()) for (const integration of integrations) assertIntegrationEnv(integration, env);
+	const { credentials } = resolveWordPressConnection(options, env);
 	return {
-		baseUrl: options?.baseUrl ?? requireEnv(defaults.baseUrlEnvKey, env),
-		siteSecret: options?.siteSecret ?? requireEnv(keys.siteSecret, env),
-		environment: options?.environment ?? process.env.NODE_ENV ?? "development",
-		connect,
-		extensions: options?.extensions,
-		adapters: {
-			...defaults.adapters,
-			...options?.adapters
-		},
+		baseUrl: options?.baseUrl ?? requireEnvValue("baseUrl", env),
+		siteSecret: options?.siteSecret ?? requireEnvValue("siteSecret", env),
+		integrations,
+		logging: options?.logging,
 		credentials,
 		wordpressEndpoints: options?.wordpress?.endpoints
 	};
 }
 /**
-* Creates a Kizlo server from the environment (`KIZLO_API_URL`, `KIZLO_WP_SECRET`,
-* `KIZLO_WP_*`), with options taking precedence. Framework packages wrap this
-* with their own URL convention and adapters.
+* Creates a Kizlo server from integration-contributed environment values, with explicit options
+* taking precedence.
 */
 function createKizlo(options) {
-	return new Kizlo(resolveKizloConfig(options, { baseUrlEnvKey: "KIZLO_API_URL" }));
+	return new Kizlo(resolveKizloConfig(options));
 }
 
 //#endregion
-export { Kizlo, createKizlo, resolveKizloConfig, resolveWordPressConnection };
+export { Kizlo, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection };

package/dist/menu/index.js

@@ -6,7 +6,7 @@ import { buildMenuGroupItem, deserializeListMenuInput, extractPath } from "./uti
 import { stringifiedMetaRecord } from "@kizlo/shared";
 
 //#region src/menu/index.ts
-const MENU_ROUTER_MAP = { items: {
+const MENU_PROCEDURES = { items: {
 	list: createProcedure({
 		scope: "api",
 		method: "GET",
@@ -86,4 +86,4 @@ const MENU_ROUTER_MAP = { items: {
 } };
 
 //#endregion
-export { MENU_ROUTER_MAP };
+export { MENU_PROCEDURES };

package/dist/nextjs/server.d.ts

@@ -2,10 +2,10 @@ import { WEB_MANIFEST_ROUTE } from "../brand/manifest.js";
 import { renderJsonLd } from "../seo/utils.js";
 import { createSitemapRedirectRoute } from "../seo/sitemap.js";
 import { NextRevalidateOptions, RevalidatePathFn, RevalidateTagFn, RevalidateTarget, nextRevalidation } from "../integrations/nextjs/revalidate.js";
-import { KizloServerOptions, createKizlo } from "../integrations/nextjs/kizlo.server.js";
+import { NextjsOptions, nextjs } from "../integrations/nextjs/integration.js";
 import { MANIFEST_CACHE_TAG, createManifestRoute } from "../integrations/nextjs/manifest.js";
 import { createHomeMetadata, createPageMetadata, createRootMetadata, createRootViewport } from "../integrations/nextjs/metadata.js";
 import { ROBOTS_CACHE_TAG, createRobotsRoute } from "../integrations/nextjs/robots.js";
 import { SITEMAP_CACHE_TAG, SITEMAP_ROUTE, createSitemapRoute } from "../integrations/nextjs/sitemap.js";
 import { createCachedTextRoute, createNextCookiesInterface, getServerBaseUrl } from "../integrations/nextjs/utils.js";
-export { KizloServerOptions, MANIFEST_CACHE_TAG, NextRevalidateOptions, ROBOTS_CACHE_TAG, RevalidatePathFn, RevalidateTagFn, RevalidateTarget, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createHomeMetadata, createKizlo, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, nextRevalidation, renderJsonLd };
+export { MANIFEST_CACHE_TAG, NextRevalidateOptions, NextjsOptions, ROBOTS_CACHE_TAG, RevalidatePathFn, RevalidateTagFn, RevalidateTarget, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createHomeMetadata, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, nextRevalidation, nextjs, renderJsonLd };

package/dist/nextjs/server.js

@@ -5,8 +5,8 @@ import { createCachedTextRoute, createNextCookiesInterface, getServerBaseUrl } f
 import { ROBOTS_CACHE_TAG, createRobotsRoute } from "../integrations/nextjs/robots.js";
 import { SITEMAP_CACHE_TAG, SITEMAP_ROUTE, createSitemapRoute } from "../integrations/nextjs/sitemap.js";
 import { nextRevalidation } from "../integrations/nextjs/revalidate.js";
-import { createKizlo } from "../integrations/nextjs/kizlo.server.js";
+import { nextjs } from "../integrations/nextjs/integration.js";
 import { MANIFEST_CACHE_TAG, createManifestRoute } from "../integrations/nextjs/manifest.js";
 import { createHomeMetadata, createPageMetadata, createRootMetadata, createRootViewport } from "../integrations/nextjs/metadata.js";
 
-export { MANIFEST_CACHE_TAG, ROBOTS_CACHE_TAG, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createHomeMetadata, createKizlo, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, nextRevalidation, renderJsonLd };
+export { MANIFEST_CACHE_TAG, ROBOTS_CACHE_TAG, SITEMAP_CACHE_TAG, SITEMAP_ROUTE, WEB_MANIFEST_ROUTE, createCachedTextRoute, createHomeMetadata, createManifestRoute, createNextCookiesInterface, createPageMetadata, createRobotsRoute, createRootMetadata, createRootViewport, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, nextRevalidation, nextjs, renderJsonLd };

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+import { NodeOptions, node } from "./integrations/node/integration.js";
+export { NodeOptions, node };

package/dist/node.js

@@ -0,0 +1,3 @@
+import { node } from "./integrations/node/integration.js";
+
+export { node };

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.15.2";
+var version = "0.17.0";
 
 //#endregion
 export { version };

package/dist/page/index.js

@@ -8,7 +8,7 @@ import { deserializePage } from "./utils.js";
 import { normalizeArrayableValue } from "@kizlo/shared";
 
 //#region src/page/index.ts
-const PAGE_ROUTER_MAP = {
+const PAGE_PROCEDURES = {
 	get: createProcedure({
 		scope: "api",
 		method: "GET",
@@ -120,4 +120,4 @@ const PAGE_ROUTER_MAP = {
 };
 
 //#endregion
-export { PAGE_ROUTER_MAP };
+export { PAGE_PROCEDURES };

package/dist/page/schema.js

@@ -1,6 +1,6 @@
-import { IdentifierInput, ListMetadata, ListOrder } from "../shared/schema.js";
+import { IdentifierInput, ListMetadata, ListOrder, customFieldsSchema } from "../shared/schema.js";
 import { Seo } from "../seo/schema.js";
-import { Media, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
+import { MediaImage, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
 import z from "zod/v4";
 
 //#region src/page/schema.ts
@@ -30,7 +30,7 @@ const PageAuthorRef = z.object({
 	id: z.number(),
 	name: z.string(),
 	slug: z.string(),
-	avatar: Media.nullable()
+	avatarUrl: z.string().nullable()
 });
 const Page = z.object({
 	id: z.number(),
@@ -47,8 +47,9 @@ const Page = z.object({
 	preview: z.boolean(),
 	status: PageStatus,
 	author: PageAuthorRef.nullable(),
-	featuredMedia: Media.nullable(),
+	featuredMedia: MediaImage.nullable(),
 	seo: Seo.nullable(),
+	custom: customFieldsSchema(),
 	createdAt: z.number(),
 	updatedAt: z.number(),
 	meta: Metadata

package/dist/page/utils.js

@@ -1,6 +1,6 @@
 import { deserializeSeo } from "../seo/utils.js";
 import { publicPostStatus } from "../post-type/status.js";
-import { resolveWpTimestamp, stringifiedMetaRecord } from "@kizlo/shared";
+import { stringifiedMetaRecord, timestampFromWpGmt } from "@kizlo/shared";
 
 //#region src/page/utils.ts
 function deserializePage(data, options) {
@@ -26,16 +26,12 @@ function deserializePage(data, options) {
 			id: kizlo.author.id,
 			name: kizlo.author.name,
 			slug: kizlo.author.slug,
-			avatar: kizlo.author.avatar_url ? {
-				id: 0,
-				alt: kizlo.author.name,
-				name: kizlo.author.name,
-				src: kizlo.author.avatar_url
-			} : null
+			avatarUrl: kizlo.author.avatar_url || null
 		} : null,
 		seo: "seo" in kizlo ? deserializeSeo(kizlo.seo) : null,
-		createdAt: resolveWpTimestamp(data.date_gmt) ?? resolveWpTimestamp(data.modified_gmt) ?? 0,
-		updatedAt: resolveWpTimestamp(data.modified_gmt) ?? 0,
+		custom: kizlo.custom,
+		createdAt: timestampFromWpGmt(data.date_gmt) ?? timestampFromWpGmt(data.modified_gmt) ?? 0,
+		updatedAt: timestampFromWpGmt(data.modified_gmt) ?? 0,
 		meta: stringifiedMetaRecord(data.meta)
 	};
 }

package/dist/post/index.js

@@ -8,7 +8,7 @@ import { deserializePost } from "./utils.js";
 import { normalizeArrayableValue } from "@kizlo/shared";
 
 //#region src/post/index.ts
-const POST_ROUTER_MAP = {
+const POST_PROCEDURES = {
 	get: createProcedure({
 		scope: "api",
 		method: "GET",
@@ -123,4 +123,4 @@ const POST_ROUTER_MAP = {
 };
 
 //#endregion
-export { POST_ROUTER_MAP };
+export { POST_PROCEDURES };

package/dist/post/schema.js

@@ -1,6 +1,6 @@
-import { IdentifierInput, ListMetadata, ListOrder } from "../shared/schema.js";
+import { IdentifierInput, ListMetadata, ListOrder, customFieldsSchema } from "../shared/schema.js";
 import { Seo } from "../seo/schema.js";
-import { BooleanLike, Media, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
+import { BooleanLike, MediaImage, Metadata, NumberLike, arrayable, lenient } from "@kizlo/shared";
 import z from "zod/v4";
 
 //#region src/post/schema.ts
@@ -43,7 +43,7 @@ const PostAuthorRef = z.object({
 	id: z.number(),
 	name: z.string(),
 	slug: z.string(),
-	avatar: Media.nullable()
+	avatarUrl: z.string().nullable()
 });
 const PostCategoryRef = z.object({
 	id: z.number(),
@@ -70,10 +70,11 @@ const Post = z.object({
 	format: PostTypeFormat,
 	sticky: z.boolean(),
 	author: PostAuthorRef.nullable(),
-	featuredMedia: Media.nullable(),
+	featuredMedia: MediaImage.nullable(),
 	categories: z.array(PostCategoryRef),
 	tags: z.array(PostTagRef),
 	seo: Seo.nullable(),
+	custom: customFieldsSchema(),
 	createdAt: z.number(),
 	updatedAt: z.number(),
 	meta: Metadata

package/dist/post/utils.js

@@ -1,6 +1,6 @@
 import { deserializeSeo } from "../seo/utils.js";
 import { publicPostStatus } from "../post-type/status.js";
-import { resolveWpTimestamp, stringifiedMetaRecord } from "@kizlo/shared";
+import { stringifiedMetaRecord, timestampFromWpGmt } from "@kizlo/shared";
 
 //#region src/post/utils.ts
 function deserializePost(data, options) {
@@ -27,17 +27,13 @@ function deserializePost(data, options) {
 			id: kizlo.author.id,
 			name: kizlo.author.name,
 			slug: kizlo.author.slug,
-			avatar: kizlo.author.avatar_url ? {
-				id: 0,
-				alt: kizlo.author.name,
-				name: kizlo.author.name,
-				src: kizlo.author.avatar_url
-			} : null
+			avatarUrl: kizlo.author.avatar_url || null
 		} : null,
 		format: data.format,
 		seo: "seo" in kizlo ? deserializeSeo(kizlo.seo) : null,
-		createdAt: resolveWpTimestamp(data.date_gmt) ?? resolveWpTimestamp(data.modified_gmt) ?? 0,
-		updatedAt: resolveWpTimestamp(data.modified_gmt) ?? 0,
+		custom: kizlo.custom,
+		createdAt: timestampFromWpGmt(data.date_gmt) ?? timestampFromWpGmt(data.modified_gmt) ?? 0,
+		updatedAt: timestampFromWpGmt(data.modified_gmt) ?? 0,
 		meta: stringifiedMetaRecord(data.meta)
 	};
 }