kizlo 0.15.2 → 0.16.0

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.16.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/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/{router.d.ts → procedures.d.ts}

@@ -4,8 +4,8 @@ import { Procedure } from "./shared/procedure.js";
 import "./index.js";
 import * as _kizlo_shared0 from "@kizlo/shared";
 
-//#region src/router.d.ts
-declare const ROUTER_MAP: {
+//#region src/procedures.d.ts
+declare const CORE_PROCEDURES: {
   posts: {
     get: Procedure<"api", {
       params: {
@@ -179,7 +179,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
+        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         taxRelation?: "AND" | "OR" | undefined;
@@ -511,7 +511,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
+        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         parent?: string | number | (string | number)[] | undefined;
@@ -772,7 +772,7 @@ declare const ROUTER_MAP: {
         exclude?: string | number | (string | number)[] | undefined;
         include?: string | number | (string | number)[] | undefined;
         order?: "asc" | "desc" | undefined;
-        orderBy?: "id" | "count" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
+        orderBy?: "count" | "id" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
         hideEmpty?: string | boolean | undefined;
         parent?: string | number | undefined;
         post?: string | number | undefined;
@@ -988,7 +988,7 @@ declare const ROUTER_MAP: {
         exclude?: string | number | (string | number)[] | undefined;
         include?: string | number | (string | number)[] | undefined;
         order?: "asc" | "desc" | undefined;
-        orderBy?: "id" | "count" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
+        orderBy?: "count" | "id" | "slug" | "name" | "description" | "include" | "include_slugs" | "term_group" | undefined;
         hideEmpty?: string | boolean | undefined;
         post?: string | number | undefined;
         slug?: string | string[] | undefined;
@@ -1202,7 +1202,7 @@ declare const ROUTER_MAP: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -1281,7 +1281,7 @@ declare const ROUTER_MAP: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -1430,7 +1430,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "id" | "date" | "parent" | "post" | "include" | undefined;
+        orderby?: "date" | "id" | "parent" | "post" | "include" | undefined;
         parent?: string | number | (string | number)[] | undefined;
         parentExclude?: string | number | (string | number)[] | undefined;
         post?: string | number | (string | number)[] | undefined;
@@ -1690,6 +1690,6 @@ declare const ROUTER_MAP: {
     };
   };
 };
-type RouterMap = typeof ROUTER_MAP;
+type CoreProcedures = typeof CORE_PROCEDURES;
 //#endregion
-export { ROUTER_MAP, RouterMap };
+export { CORE_PROCEDURES, CoreProcedures };

package/dist/procedures.js

@@ -0,0 +1,23 @@
+import { CATEGORY_PROCEDURES } from "./category/index.js";
+import { COMMENT_PROCEDURES } from "./comment/index.js";
+import { MENU_PROCEDURES } from "./menu/index.js";
+import { PAGE_PROCEDURES } from "./page/index.js";
+import { POST_PROCEDURES } from "./post/index.js";
+import { SEO_PROCEDURES } from "./seo/index.js";
+import { SETTINGS_PROCEDURES } from "./settings/index.js";
+import { TAG_PROCEDURES } from "./tag/index.js";
+
+//#region src/procedures.ts
+const CORE_PROCEDURES = {
+	posts: POST_PROCEDURES,
+	pages: PAGE_PROCEDURES,
+	categories: CATEGORY_PROCEDURES,
+	tags: TAG_PROCEDURES,
+	seo: SEO_PROCEDURES,
+	menus: MENU_PROCEDURES,
+	comments: COMMENT_PROCEDURES,
+	settings: SETTINGS_PROCEDURES
+};
+
+//#endregion
+export { CORE_PROCEDURES };

package/dist/seo/index.js

@@ -23,7 +23,7 @@ function deserializeSitemapUrls(urls) {
 		}))
 	}));
 }
-const SEO_ROUTER_MAP = {
+const SEO_PROCEDURES = {
 	homepage: createProcedure({
 		scope: "internal",
 		output: Seo
@@ -111,4 +111,4 @@ const SEO_ROUTER_MAP = {
 };
 
 //#endregion
-export { SEO_ROUTER_MAP };
+export { SEO_PROCEDURES };

package/dist/settings/index.js

@@ -12,7 +12,7 @@ function resolveUpdate(response, context, errors, label) {
 	}
 	return response.data;
 }
-const SETTINGS_ROUTER_MAP = {
+const SETTINGS_PROCEDURES = {
 	get: createProcedure({
 		scope: "internal",
 		output: schemaType()
@@ -73,4 +73,4 @@ const SETTINGS_ROUTER_MAP = {
 };
 
 //#endregion
-export { SETTINGS_ROUTER_MAP };
+export { SETTINGS_PROCEDURES };

package/dist/shared/constants.js

@@ -5,14 +5,6 @@ import { milliseconds } from "@kizlo/shared";
 const VERSION = version;
 const RPC_PROTOCOL_HEADER = "x-rpc-protocol";
 const SESSION_EXPIRY_MARGIN_MS = milliseconds("5 minutes");
-/**
-* Set in `process.env` by the CLI daemon while it imports the server module solely to read the
-* router's *shape* for contract generation. No request is served in that mode, so `requireEnv`
-* returns a placeholder instead of aborting the import when connection env vars are absent — the
-* router shape doesn't depend on any env value, and framework virtual modules (e.g. Astro's
-* `getSecret`) are stubbed to `undefined` during the shape-only import anyway.
-*/
-const CONTRACT_GENERATION_ENV = "KIZLO_CONTRACT_GENERATION";
 
 //#endregion
-export { CONTRACT_GENERATION_ENV, RPC_PROTOCOL_HEADER };
+export { RPC_PROTOCOL_HEADER };

package/dist/shared/contract-generation.js

@@ -0,0 +1,14 @@
+//#region src/shared/contract-generation.ts
+const CONTRACT_GENERATION = Symbol.for("kizlo.contract-generation");
+function state() {
+	return globalThis;
+}
+function isContractGeneration() {
+	return state()[CONTRACT_GENERATION] === true;
+}
+function setContractGeneration(value) {
+	state()[CONTRACT_GENERATION] = value;
+}
+
+//#endregion
+export { isContractGeneration, setContractGeneration };