kizlo 0.15.2 → 0.16.0

package/dist/adapters/logger.d.ts

@@ -1,8 +1,5 @@
-import { LiteralUnion } from "@kizlo/shared";
-
 //#region src/adapters/logger.d.ts
 type LogLevel = "debug" | "info" | "warn" | "error";
-type Environment = LiteralUnion<"development" | "production" | "test", string>;
 interface LogPayload {
   /** Severity of the record: `debug`, `info`, `warn`, or `error`. */
   level: LogLevel;
@@ -16,7 +13,7 @@ interface LogPayload {
   error?: Error;
 }
 type LoggerAdapter = (payload: LogPayload) => void | Promise<void>;
-/** Author a custom logger adapter — types your handler against the {@link LoggerAdapter} contract. */
+/** Author a custom logger adapter. Types your handler against the {@link LoggerAdapter} contract. */
 declare function createLoggerAdapter(adapter: LoggerAdapter): LoggerAdapter;
 interface Logger {
   debug(message: string, context?: Record<string, unknown>): void;
@@ -35,4 +32,4 @@ interface ConsoleLogAdapterOptions {
 declare function consoleLog(opts?: ConsoleLogAdapterOptions): LoggerAdapter;
 declare const noopAdapter: LoggerAdapter;
 //#endregion
-export { ConsoleLogAdapterOptions, Environment, LogLevel, LogPayload, Logger, LoggerAdapter, consoleLog, createLoggerAdapter, noopAdapter };
+export { ConsoleLogAdapterOptions, LogLevel, LogPayload, Logger, LoggerAdapter, consoleLog, createLoggerAdapter, noopAdapter };

package/dist/adapters/logger.js

@@ -1,5 +1,5 @@
 //#region src/adapters/logger.ts
-/** Author a custom logger adapter — types your handler against the {@link LoggerAdapter} contract. */
+/** Author a custom logger adapter. Types your handler against the {@link LoggerAdapter} contract. */
 function createLoggerAdapter(adapter) {
 	return adapter;
 }

package/dist/adapters/types.d.ts

@@ -0,0 +1,19 @@
+import { AuthAdapter } from "./auth.js";
+import { CaptchaAdapter } from "./captcha.js";
+import { CookiesAdapter } from "../shared/types.js";
+import { GeoAdapter } from "./geo.js";
+import { LoggerAdapter } from "./logger.js";
+
+//#region src/adapters/types.d.ts
+/** The service contracts Kizlo integrations can provide at runtime. */
+interface ServiceAdapters {
+  auth?: AuthAdapter;
+  captcha?: CaptchaAdapter;
+  geo?: GeoAdapter;
+  logger?: LoggerAdapter;
+  cookies?: CookiesAdapter;
+}
+/** Merge adapter contributions in order without letting `undefined` erase an earlier value. */
+declare function mergeServiceAdapters(...contributions: (ServiceAdapters | undefined)[]): ServiceAdapters;
+//#endregion
+export { ServiceAdapters, mergeServiceAdapters };

package/dist/adapters/types.js

@@ -0,0 +1,17 @@
+//#region src/adapters/types.ts
+/** Merge adapter contributions in order without letting `undefined` erase an earlier value. */
+function mergeServiceAdapters(...contributions) {
+	const adapters = {};
+	for (const contribution of contributions) {
+		if (!contribution) continue;
+		if (contribution.auth !== void 0) adapters.auth = contribution.auth;
+		if (contribution.captcha !== void 0) adapters.captcha = contribution.captcha;
+		if (contribution.geo !== void 0) adapters.geo = contribution.geo;
+		if (contribution.logger !== void 0) adapters.logger = contribution.logger;
+		if (contribution.cookies !== void 0) adapters.cookies = contribution.cookies;
+	}
+	return adapters;
+}
+
+//#endregion
+export { mergeServiceAdapters };

package/dist/astro/server.d.ts

@@ -1,9 +1,9 @@
 import { WEB_MANIFEST_ROUTE } from "../brand/manifest.js";
 import { renderJsonLd } from "../seo/utils.js";
-import { KizloServerOptions, createKizlo } from "../integrations/astro/kizlo.server.js";
+import { AstroOptions, astro } from "../integrations/astro/integration.js";
 import { AstroRoute, AstroRouteContext, getServerBaseUrl } from "../integrations/astro/utils.js";
 import { createManifestRoute } from "../integrations/astro/manifest.js";
 import { PageHead, RootHead, ThemeColor, resolvePageHead, resolveRootHead } from "../integrations/astro/metadata.js";
 import { createRobotsRoute } from "../integrations/astro/robots.js";
 import { createSitemapRedirectRoute, createSitemapRoute } from "../integrations/astro/sitemap.js";
-export { AstroRoute, AstroRouteContext, KizloServerOptions, PageHead, RootHead, ThemeColor, WEB_MANIFEST_ROUTE, createKizlo, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead };
+export { AstroOptions, AstroRoute, AstroRouteContext, PageHead, RootHead, ThemeColor, WEB_MANIFEST_ROUTE, astro, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead };

package/dist/astro/server.js

@@ -1,10 +1,10 @@
 import { WEB_MANIFEST_ROUTE } from "../brand/manifest.js";
 import { renderJsonLd } from "../seo/utils.js";
 import { getServerBaseUrl } from "../integrations/astro/utils.js";
-import { createKizlo } from "../integrations/astro/kizlo.server.js";
+import { astro } from "../integrations/astro/integration.js";
 import { createManifestRoute } from "../integrations/astro/manifest.js";
 import { resolvePageHead, resolveRootHead } from "../integrations/astro/metadata.js";
 import { createRobotsRoute } from "../integrations/astro/robots.js";
 import { createSitemapRedirectRoute, createSitemapRoute } from "../integrations/astro/sitemap.js";
 
-export { WEB_MANIFEST_ROUTE, createKizlo, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead };
+export { WEB_MANIFEST_ROUTE, astro, createManifestRoute, createRobotsRoute, createSitemapRedirectRoute, createSitemapRoute, getServerBaseUrl, renderJsonLd, resolvePageHead, resolveRootHead };

package/dist/category/index.js

@@ -7,7 +7,7 @@ import { deserializeCategory } from "./utils.js";
 import { normalizeArrayableValue } from "@kizlo/shared";
 
 //#region src/category/index.ts
-const CATEGORY_ROUTER_MAP = {
+const CATEGORY_PROCEDURES = {
 	get: createProcedure({
 		scope: "api",
 		method: "GET",
@@ -74,4 +74,4 @@ const CATEGORY_ROUTER_MAP = {
 };
 
 //#endregion
-export { CATEGORY_ROUTER_MAP };
+export { CATEGORY_PROCEDURES };

package/dist/cli/commands/_setup.js

@@ -37,17 +37,17 @@ function remoteKeys(envKeys) {
 }
 /**
 * The `.env` keys setup manages and the values to write, branched on the connection mode. Local
-* WordPress writes the `KIZLO_LOCAL_WP_*` / `KIZLO_LOCAL_WP_SECRET` set plus `KIZLO_CONNECT=local`,
+* WordPress writes the `KIZLO_LOCAL_WP_*` / `KIZLO_LOCAL_WP_SECRET` set plus `KIZLO_MODE=local`,
 * so it never touches the remote keys (a user can point those at a real site). A remote site writes
-* the bare remote keys exactly as before — no `KIZLO_CONNECT`, since `"remote"` is the default.
+* the bare remote keys exactly as before — no `KIZLO_MODE`, since `"remote"` is the default.
 */
 function managedEnv(envKeys, conn) {
 	if (conn.mode === "local") {
-		const { connect, siteSecret: siteSecret$1, wpUrl: wpUrl$1, wpUsername: wpUsername$1, wpPassword: wpPassword$1 } = envKeys.local;
+		const { mode, siteSecret: siteSecret$1, wpUrl: wpUrl$1, wpUsername: wpUsername$1, wpPassword: wpPassword$1 } = envKeys.local;
 		return {
 			keys: [
 				envKeys.baseUrl,
-				connect,
+				mode,
 				siteSecret$1,
 				wpUrl$1,
 				wpUsername$1,
@@ -55,7 +55,7 @@ function managedEnv(envKeys, conn) {
 			],
 			values: {
 				[envKeys.baseUrl]: conn.baseUrl,
-				[connect]: "local",
+				[mode]: "local",
 				[siteSecret$1]: conn.siteSecret,
 				[wpUrl$1]: conn.wpUrl,
 				[wpUsername$1]: conn.wpUsername,
@@ -375,7 +375,7 @@ async function provisionLocalStack(cfg, siteSecret, baseUrl) {
 		url: info.url,
 		username: info.username,
 		appPassword,
-		adminPassword: info.secrets?.password,
+		adminPassword: info.adminPassword,
 		secretSyncError: sync.ok ? void 0 : sync.error
 	};
 }
@@ -398,7 +398,7 @@ async function provisionLocalWordPress(cwd, conn) {
 }
 /**
 * The template's own `.env.example`, when it ships one. Templates own the framework-specific key names
-* (e.g. `NEXT_PUBLIC_KIZLO_API_URL`) and the shared section layout, so their file is the source of the
+* (e.g. `NEXT_PUBLIC_KIZLO_BASE_URL`) and the shared section layout, so their file is the source of the
 * scaffold's `.env.example` — see {@link writeEnv}. Undefined for the base preset (no template dir).
 */
 function readEnvExample(templateDir) {
@@ -407,14 +407,14 @@ function readEnvExample(templateDir) {
 }
 /**
 * The `.env.example` body for the base preset, which ships no template file. Lists the API URL and the
-* remote connection keys, then the commented `KIZLO_CONNECT=local` toggle for the local-dev path. Real
+* remote connection keys, then the commented `KIZLO_MODE=local` toggle for the local-dev path. Real
 * templates carry their own `.env.example` (passed to {@link writeEnv}) so its structure and comments
 * stay consistent with the `.env` the scaffold writes.
 */
 function generatedEnvExample(envKeys) {
 	const exampleKeys = [envKeys.baseUrl, ...remoteKeys(envKeys)];
 	const { content } = mergeEnv("", Object.fromEntries(exampleKeys.map((key) => [key, ""])), new Set(exampleKeys), envGroups(envKeys));
-	return `${content}\n# Point the app at local WordPress (managed by \`kizlo dev\`) instead of the keys above:\n# ${envKeys.local.connect}=local\n`;
+	return `${content}\n# Point the app at local WordPress (managed by \`kizlo dev\`) instead of the keys above:\n# ${envKeys.local.mode}=local\n`;
 }
 /**
 * The managed keys already present in an existing `.env` — the values a write would overwrite. Collected
@@ -471,7 +471,7 @@ function nextStepsLines(conn, prefix = "") {
 	const login = conn.mode === "local" && conn.adminPassword ? [
 		``,
 		`Log in to wp-admin (${conn.wpUrl}/wp-admin):`,
-		`  ${conn.wpUsername} / ${conn.adminPassword} — save it, it's shown only once`
+		`  ${conn.wpUsername} / ${conn.adminPassword}`
 	] : [];
 	return [
 		`Start developing:`,

package/dist/cli/commands/dev.js

@@ -42,7 +42,7 @@ function note(text) {
 * Print the connection summary as an aligned, Next.js-style block. Shows the wp-admin URL on
 * the loopback ("Local") and — when local WordPress is installed on a LAN address rather than
 * localhost — on the network, so it can be opened from other devices. On a fresh install, also
-* show the one-time wp-admin password (it's never stored, so this is the only chance to see it).
+* show the default wp-admin login.
 */
 function printSummary(info) {
 	const { cyan, dim, reset } = palette();
@@ -52,7 +52,7 @@ function printSummary(info) {
 	rows.push(["Database Connection", `127.0.0.1:${info.dbPort}`]);
 	const width = Math.max(...rows.map(([label]) => label.length)) + 1;
 	const lines = ["", ...rows.map(([label, value]) => `   ${dim}- ${`${label}:`.padEnd(width)}${reset} ${cyan}${value}${reset}`)];
-	if (info.secrets) lines.push("", `   ${dim}admin login:${reset} ${info.username} / ${info.secrets.password}`, `   ${dim}save the password now — it's shown only once${reset}`);
+	if (info.adminPassword) lines.push("", `   ${dim}admin login:${reset} ${info.username} / ${info.adminPassword}`);
 	if (info.seeded > 0) lines.push(`   ${dim}seeded ${info.seeded} fixture${info.seeded === 1 ? "" : "s"}${reset}`);
 	process.stdout.write(`${lines.join("\n")}\n`);
 }
@@ -71,13 +71,13 @@ function readEnvValue(content, key) {
 	return content.match(new RegExp(`^\\s*${key}\\s*=\\s*(.*)$`, "m"))?.[1]?.trim() || void 0;
 }
 /**
-* The Kizlo backend URL from `.env` — the one key ending in `KIZLO_API_URL` (`KIZLO_API_URL`,
-* or a framework-prefixed `NEXT_PUBLIC_KIZLO_API_URL`). It's the handler mount the plugin delivers
+* The Kizlo backend URL from `.env` — the one key ending in `KIZLO_BASE_URL` (`KIZLO_BASE_URL`,
+* or a framework-prefixed `NEXT_PUBLIC_KIZLO_BASE_URL`). It's the handler mount the plugin delivers
 * webhook events to; its origin is the site's canonical URL. User-managed (init writes it), so dev
 * only reads it. Undefined before `kizlo init` has populated `.env`.
 */
 function readBaseUrl(content) {
-	return content.match(/^\s*[A-Z_]*KIZLO_API_URL\s*=\s*(.*)$/m)?.[1]?.trim() || void 0;
+	return content.match(/^\s*[A-Z_]*KIZLO_BASE_URL\s*=\s*(.*)$/m)?.[1]?.trim() || void 0;
 }
 /**
 * Rewrite the local WordPress connection in `.env` after a fresh install. A reset (or first boot)
@@ -86,7 +86,7 @@ function readBaseUrl(content) {
 * connection keys are overwritten; everything else in `.env` is preserved, and the file is created
 * if absent. Gated by the caller on a minted `appPassword`, so a warm resume never churns it.
 *
-* `KIZLO_CONNECT=local` and `KIZLO_LOCAL_WP_SECRET` are written too but kept out of the overwrite set,
+* `KIZLO_MODE=local` and `KIZLO_LOCAL_WP_SECRET` are written too but kept out of the overwrite set,
 * so a value the user already set is preserved — booting local WordPress only fills them when absent.
 * The resolved local secret (the existing one, or a freshly minted one) and the Kizlo server base URL
 * are returned so the caller can sync them into the plugin.
@@ -101,7 +101,7 @@ function updateWpEnv(cfg, info) {
 		KIZLO_LOCAL_WP_USERNAME: info.username,
 		KIZLO_LOCAL_WP_APP_PASSWORD: info.appPassword,
 		KIZLO_LOCAL_WP_SECRET: siteSecret,
-		KIZLO_CONNECT: "local"
+		KIZLO_MODE: "local"
 	}, new Set(WP_ENV_KEYS), envGroups(DEFAULT_ENV_KEYS));
 	writeFileSync(envPath, content);
 	return {

package/dist/cli/daemon/generate.js

@@ -1,6 +1,7 @@
 import { generateContract } from "../../shared/contract.js";
-import { resolveWordPressConnection } from "../../kizlo.js";
+import { integrationEnv, resolveWordPressConnection } from "../../kizlo.js";
 import { WORDPRESS_CLIENT_META_REL } from "../wp/constants.js";
+import { node } from "../../integrations/node/integration.js";
 import { log } from "./logger.js";
 import { loadEnvFiles } from "../utils.js";
 import { importIgnoringVirtualModules } from "./jiti.js";
@@ -14,21 +15,27 @@ import fs from "node:fs";
 
 //#region src/cli/daemon/generate.ts
 /**
-* The generated barrel — also written as a stub by `kizlo init`. It re-exports `endpoints` rather
+* The generated barrel is also written as a stub by `kizlo init`. It re-exports `endpoints` rather
 * than pre-wrapping it: a server entry passes `wordpress: { endpoints }` itself, so the rest of the
 * WordPress options stay visible at the call site instead of hiding inside a generated object.
 */
 const CONTRACT_BARREL = [
-	`import type { router } from ".."`,
+	`import type { procedures } from ".."`,
 	`import contractJson from "./contract.json"`,
 	``,
-	`export const contract = contractJson as unknown as typeof router`,
+	`export const contract = contractJson as unknown as typeof procedures`,
 	`export { endpoints, type WordPressClient } from "./wordpress"`,
 	``
 ].join("\n");
+var LegacyRouterExportError = class extends Error {
+	name = "LegacyRouterExportError";
+	constructor(entry) {
+		super(`The Kizlo server at ${entry} exports \`router\`, which is no longer supported. Rename that export to \`procedures\` and run \`kizlo generate\` again.`);
+	}
+};
 /**
 * `wordpress.ts` before the first generation. WordPress is reachable but untyped until then, so a
-* freshly scaffolded project compiles — including kizlo's own procedures — before it has ever
+* freshly scaffolded project compiles, including Kizlo's own procedures, before it has ever
 * connected. `kizlo dev` / `kizlo generate` replaces this with the real client. `any` rather than an
 * empty tree on purpose: every endpoint a procedure names has to resolve to something until the
 * real shapes arrive, which `WP_Client` preserves by passing `any` through.
@@ -165,7 +172,7 @@ function reportPluginVersion(installed) {
 /** Fetch `/introspect`, reporting its diagnostics in the CLI's voice. Returns undefined on a 304. */
 async function fetchDocument(cwd, options, etag) {
 	loadEnvFiles(cwd);
-	const result = await fetchIntrospection(options.credentials ?? resolveWordPressConnection(void 0).credentials, {
+	const result = await fetchIntrospection(options.credentials ?? resolveWordPressConnection(void 0, integrationEnv([node()])).credentials, {
 		etag: options.strict ? void 0 : etag,
 		fetch: options.fetch
 	});
@@ -231,9 +238,12 @@ function writeGeneratedWordPress(cfg, client, meta) {
 async function generateOnce(cfg, options = {}) {
 	loadEnvFiles(cfg.cwd);
 	const entry = path.resolve(cfg.cwd, cfg.serverEntry);
-	const { router } = await importIgnoringVirtualModules(cfg.cwd, entry);
-	if (!router) return false;
-	const contract = JSON.stringify(await generateContract(router));
+	const server = await importIgnoringVirtualModules(cfg.cwd, entry);
+	if (!server.procedures) {
+		if (server.router) throw new LegacyRouterExportError(cfg.serverEntry);
+		return false;
+	}
+	const contract = JSON.stringify(await generateContract(server.procedures));
 	const wordpress = await generateWordPressOnce(cfg, options);
 	fs.mkdirSync(path.resolve(cfg.cwd, cfg.generatedDir), { recursive: true });
 	atomicWrite(path.resolve(cfg.cwd, cfg.contractPath), contract);

package/dist/cli/daemon/jiti.js

@@ -1,4 +1,4 @@
-import { CONTRACT_GENERATION_ENV } from "../../shared/constants.js";
+import { isContractGeneration, setContractGeneration } from "../../shared/contract-generation.js";
 import path from "node:path";
 import fs from "node:fs";
 import { createJiti } from "jiti";
@@ -20,13 +20,12 @@ import { createJiti } from "jiti";
 async function importIgnoringVirtualModules(cwd, entry) {
 	const deps = declaredDeps(cwd);
 	const virtualModules = {};
-	const previousGenerationFlag = process.env[CONTRACT_GENERATION_ENV];
-	process.env[CONTRACT_GENERATION_ENV] = "1";
+	const previousGenerationFlag = isContractGeneration();
+	setContractGeneration(true);
 	try {
 		return await importLoop(cwd, entry, deps, virtualModules);
 	} finally {
-		if (previousGenerationFlag === void 0) delete process.env[CONTRACT_GENERATION_ENV];
-		else process.env[CONTRACT_GENERATION_ENV] = previousGenerationFlag;
+		setContractGeneration(previousGenerationFlag);
 	}
 }
 async function importLoop(cwd, entry, deps, virtualModules) {

package/dist/cli/daemon/watch.js

@@ -1,4 +1,5 @@
-import { resolveWordPressConnection } from "../../kizlo.js";
+import { integrationEnv, resolveWordPressConnection } from "../../kizlo.js";
+import { node } from "../../integrations/node/integration.js";
 import { log } from "./logger.js";
 import { loadEnvFiles } from "../utils.js";
 import { resolveConfig, resolveWordPressClientDir } from "./config.js";
@@ -149,7 +150,7 @@ async function startWatcher(cwd, opts) {
 			return;
 		}
 		loadEnvFiles(cwd);
-		const { credentials } = resolveWordPressConnection(void 0);
+		const { credentials } = resolveWordPressConnection(void 0, integrationEnv([node()]));
 		if (wordpressClientDir) try {
 			if (await generateWorkspaceClientOnce(cwd, wordpressClientDir, { credentials }) === "generated") log.success("WordPress client generated");
 		} catch (error) {

package/dist/cli/presets/template.js

@@ -212,7 +212,7 @@ const envSchema = z.object({
 		wpPassword: z.string()
 	}),
 	local: z.object({
-		connect: z.string(),
+		mode: z.string(),
 		siteSecret: z.string(),
 		wpUrl: z.string(),
 		wpUsername: z.string(),

package/dist/cli/utils.js

@@ -460,7 +460,7 @@ function envKeysPresent(contents, keys) {
 * first stamped release). Real templates carry their own `env`, so this is the standard `KIZLO_*` set.
 */
 const DEFAULT_ENV_KEYS = {
-	baseUrl: "KIZLO_API_URL",
+	baseUrl: "KIZLO_BASE_URL",
 	remote: {
 		siteSecret: "KIZLO_WP_SECRET",
 		wpUrl: "KIZLO_WP_URL",
@@ -468,7 +468,7 @@ const DEFAULT_ENV_KEYS = {
 		wpPassword: "KIZLO_WP_APP_PASSWORD"
 	},
 	local: {
-		connect: "KIZLO_CONNECT",
+		mode: "KIZLO_MODE",
 		siteSecret: "KIZLO_LOCAL_WP_SECRET",
 		wpUrl: "KIZLO_LOCAL_WP_URL",
 		wpUsername: "KIZLO_LOCAL_WP_USERNAME",
@@ -477,7 +477,7 @@ const DEFAULT_ENV_KEYS = {
 };
 /**
 * The grouped `.env` layout shared by `init` and `dev`, so both write the same sectioned file:
-* a connect switch, the API URL, then the remote and local connection blocks. The key names come from
+* a mode switch, the base URL, then the remote and local connection blocks. The key names come from
 * the resolved {@link EnvKeys} (the template's `env` contract), so the sections stay labelled correctly
 * whatever a template calls them. Only sections whose keys are actually being appended get a header, so
 * a remote run skips the local block and vice versa.
@@ -485,11 +485,11 @@ const DEFAULT_ENV_KEYS = {
 function envGroups(envKeys) {
 	return [
 		{
-			comment: "Kizlo Connect (local | remote)",
-			keys: [envKeys.local.connect]
+			comment: "Kizlo Mode (local | remote)",
+			keys: [envKeys.local.mode]
 		},
 		{
-			comment: "Kizlo API URL",
+			comment: "Kizlo Base URL",
 			keys: [envKeys.baseUrl]
 		},
 		{

package/dist/cli/wp/bootstrap.js

@@ -3,6 +3,19 @@ import { compose, composeUp, wpCli, wpEval } from "./docker.js";
 import { ensurePlugins, settleFixtures } from "./utils.js";
 
 //#region src/cli/wp/bootstrap.ts
+/** Install a local WordPress site with the shared admin credentials. */
+async function installWordPress(url, title) {
+	await wpCli([
+		"core",
+		"install",
+		`--url=${url}`,
+		`--title=${title}`,
+		`--admin_user=${TEST_ADMIN.username}`,
+		`--admin_password=${TEST_ADMIN.password}`,
+		`--admin_email=${TEST_ADMIN.email}`,
+		"--skip-email"
+	]);
+}
 async function seedUsers() {
 	const existing = await wpCli([
 		"user",
@@ -59,16 +72,7 @@ async function bootstrapWp(config) {
 		"wp",
 		"core",
 		"is-installed"
-	])).code !== 0) await wpCli([
-		"core",
-		"install",
-		`--url=${url}`,
-		"--title=Kizlo Test",
-		`--admin_user=${TEST_ADMIN.username}`,
-		`--admin_password=${TEST_ADMIN.password}`,
-		`--admin_email=${TEST_ADMIN.email}`,
-		"--skip-email"
-	]);
+	])).code !== 0) await installWordPress(url, "Kizlo Test");
 	await wpCli([
 		"rewrite",
 		"structure",
@@ -118,4 +122,4 @@ async function bootstrapWp(config) {
 }
 
 //#endregion
-export { bootstrapWp, createAdminAppPassword, seedUsers };
+export { bootstrapWp, createAdminAppPassword, installWordPress, seedUsers };

package/dist/cli/wp/constants.js

@@ -70,7 +70,7 @@ const TEST_ADMIN = {
 	firstName: "Admin",
 	lastName: "",
 	username: "admin",
-	password: "admin_pass",
+	password: "admin",
 	email: "admin@example.com"
 };
 const TEST_USER = {

package/dist/cli/wp/dev.js

@@ -4,17 +4,12 @@ import { compose, composePull, composeUp, wpCli, wpEval } from "./docker.js";
 import { ensurePlugins, settleFixtures } from "./utils.js";
 import { log } from "../daemon/logger.js";
 import { warnVersionDrift } from "./version.js";
-import { createAdminAppPassword, seedUsers } from "./bootstrap.js";
+import { createAdminAppPassword, installWordPress, seedUsers } from "./bootstrap.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { randomBytes } from "node:crypto";
 import { networkInterfaces } from "node:os";
 
 //#region src/cli/wp/dev.ts
-/** A strong random admin password (144 bits, URL/JSON/CLI-safe characters). */
-function generatePassword() {
-	return randomBytes(18).toString("base64url");
-}
 const VIRTUAL_INTERFACE = /^(?:docker|br-|veth|utun|tun|tap)/i;
 const PRIVATE_IPV4 = /^(?:10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.)/;
 /** Preferred private IPv4 address on a physical interface (undefined when offline). */
@@ -74,9 +69,8 @@ async function seedDevFixtures(cfg, url) {
 * sources + bind-mounted locals). An already-provisioned install is left untouched
 * (idempotent reruns).
 *
-* Credentials are an output, not a stored file: a fresh install mints a random admin
-* password and returns it once (to log into wp-admin). No application password is minted —
-* that's a test concern.
+* A fresh install uses the shared local admin credentials and returns the password so
+* the command can show the login. Existing installs are left untouched.
 */
 async function bootstrapDev(cfg) {
 	const url = devUrl(cfg.port);
@@ -90,19 +84,8 @@ async function bootstrapDev(cfg) {
 		"core",
 		"is-installed"
 	])).code === 0;
-	let password;
 	if (!installed) {
-		password = generatePassword();
-		await wpCli([
-			"core",
-			"install",
-			`--url=${url}`,
-			"--title=Kizlo Dev",
-			`--admin_user=${TEST_ADMIN.username}`,
-			`--admin_password=${password}`,
-			`--admin_email=${TEST_ADMIN.email}`,
-			"--skip-email"
-		]);
+		await installWordPress(url, "Kizlo Dev");
 		await wpCli([
 			"rewrite",
 			"structure",
@@ -122,14 +105,14 @@ async function bootstrapDev(cfg) {
 		wpEval
 	});
 	const seeded = !installed && cfg.fixtures.length ? await seedDevFixtures(cfg, url) : 0;
-	const appPassword = password ? await createAdminAppPassword("kizlo-dev") : void 0;
+	const appPassword = !installed ? await createAdminAppPassword("kizlo-dev") : void 0;
 	return {
 		url,
 		username: TEST_ADMIN.username,
 		dbPort: cfg.dbPort,
 		seeded,
 		appPassword,
-		secrets: password ? { password } : void 0
+		adminPassword: !installed ? TEST_ADMIN.password : void 0
 	};
 }
 

package/dist/cli/wp/types.d.ts

@@ -87,7 +87,7 @@ interface SettleContext {
 type FixtureSeedFn = (ctx: SeedContext) => Promise<Record<string, JsonValue>>;
 type FixtureSettleFn = (ctx: SettleContext) => Promise<void>;
 type FixtureCleanupFn = (ctx: SeedContext) => Promise<void>;
-/** The serializable test layer an extension ships alongside its live extension. */
+/** The serializable test layer an integration ships alongside its live code. */
 interface Fixture {
   /** Namespace key under `TestCredentials.fixtures`. */
   name: string;
@@ -107,7 +107,7 @@ interface Fixture {
    * a minute ago and one booted last week describe the same WordPress.
    */
   settle?: FixtureSettleFn;
-  /** Build this extension's world once during seeding; return created handles. */
+  /** Build this integration's world once during seeding; return created handles. */
   seed?: FixtureSeedFn;
   /** Revert per-test mutations (teardown); does NOT uninstall plugins or seeded data. */
   cleanup?: FixtureCleanupFn;

package/dist/cli/wp/utils.d.ts

@@ -31,7 +31,7 @@ declare function ensurePlugin(name: string, source: string): Promise<void>;
 declare function activateLocalPlugin(pluginPath: string): Promise<void>;
 /**
  * Ensure every plugin is active. Installable sources go first so a bind-mounted
- * local plugin that depends on one (e.g. a WooCommerce extension) finds it already
+ * local plugin that depends on one (e.g. a WooCommerce integration) finds it already
  * present; then each {@link LocalPlugin} is activated by basename. A local plugin
  * whose slug matches an installable (e.g. mounting `kizlo` over the released
  * `kizlo`) is seen as already installed, so `ensurePlugin` activates the live

package/dist/cli/wp/utils.js

@@ -95,7 +95,7 @@ async function activateLocalPlugin(pluginPath) {
 }
 /**
 * Ensure every plugin is active. Installable sources go first so a bind-mounted
-* local plugin that depends on one (e.g. a WooCommerce extension) finds it already
+* local plugin that depends on one (e.g. a WooCommerce integration) finds it already
 * present; then each {@link LocalPlugin} is activated by basename. A local plugin
 * whose slug matches an installable (e.g. mounting `kizlo` over the released
 * `kizlo`) is seen as already installed, so `ensurePlugin` activates the live

package/dist/client.d.ts

@@ -1,23 +1,23 @@
-import { AnyProcedureRouter, ExtractProcedureByScope } from "./shared/procedure.js";
+import { AnyProcedureTree, ExtractProcedureByScope } from "./shared/procedure.js";
 import { ResultClient } from "./shared/result.js";
 
 //#region src/client.d.ts
-interface KizloClientConfig<T extends AnyProcedureRouter> {
+interface KizloClientConfig<T extends AnyProcedureTree> {
   url?: string;
   contract: T;
   fetch?: (request: Request) => Promise<Response>;
 }
-declare class KizloClient<TRouter extends AnyProcedureRouter> {
-  readonly client: ResultClient<ExtractProcedureByScope<TRouter, "remote" | "api">>;
-  protected readonly config: KizloClientConfig<TRouter>;
-  constructor(config: KizloClientConfig<TRouter>);
+declare class KizloClient<TProcedures extends AnyProcedureTree> {
+  readonly client: ResultClient<ExtractProcedureByScope<TProcedures, "remote" | "api">>;
+  protected readonly config: KizloClientConfig<TProcedures>;
+  constructor(config: KizloClientConfig<TProcedures>);
   private getUrl;
 }
 /**
  * Creates a browser client for a generated contract. Defaults the URL to the
  * current origin (`window.location.origin`); framework packages wrap this to resolve it from their env.
  */
-declare function createKizloClient<T extends AnyProcedureRouter>(contract: T, options?: {
+declare function createKizloClient<T extends AnyProcedureTree>(contract: T, options?: {
   url?: string;
 }): KizloClient<T>;
 //#endregion

package/dist/client.js

@@ -27,7 +27,7 @@ var KizloClient = class {
 		});
 		this.client = createResultClient(createORPCClient(new DynamicLink((_, path) => {
 			const procedure = getObjectProperty(this.config.contract, path);
-			if (!isContractProcedure$1(procedure)) throw new Error(`No valid procedure found at path "${path.join(".")}". This may happen when the contract router is not properly configured.`);
+			if (!isContractProcedure$1(procedure)) throw new Error(`No valid procedure found at path "${path.join(".")}". The generated contract may not match the exported procedures.`);
 			switch (procedure.scope) {
 				case "internal": throw new Error("Internal procedure can only be called on the server.");
 				case "api": return openapiLink;

package/dist/comment/index.js

@@ -6,7 +6,7 @@ import { deserializeComment } from "./utils.js";
 import { listed } from "@kizlo/shared";
 
 //#region src/comment/index.ts
-const COMMENT_ROUTER_MAP = {
+const COMMENT_PROCEDURES = {
 	get: createProcedure({
 		scope: "api",
 		method: "GET",
@@ -147,4 +147,4 @@ const COMMENT_ROUTER_MAP = {
 };
 
 //#endregion
-export { COMMENT_ROUTER_MAP };
+export { COMMENT_PROCEDURES };