kizlo 0.17.0 → 0.19.0

package/dist/cli/daemon/config.js

@@ -1,4 +1,4 @@
-import { DEFAULT_WORDPRESS_TAG, LOCAL_DIR_REL, WORDPRESS_META_REL } from "../wp/constants.js";
+import { DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL } from "../wp/constants.js";
 import { credentialsPath, findConfigDir } from "../wp/utils.js";
 import { log } from "./logger.js";
 import { detectPackageManager } from "../utils.js";
@@ -11,39 +11,82 @@ import fs from "node:fs";
 //#region src/cli/daemon/config.ts
 const fixtureSchema = z.custom((value) => typeof value === "object" && value !== null && typeof value.name === "string", { message: "must be a fixture object with a string `name` (use defineFixture)" });
 /**
-* `dev.version` / `test.version`. Validated against Docker's tag grammar here rather than at boot,
-* so `"wordpress:7.1.0"`, which would resolve to `wordpress:wordpress:7.1.0`, is named as a config
-* mistake instead of surfacing as a pull failure seconds into starting a stack.
+* `local.dev.version` / `local.test.version`. Validated against Docker's tag grammar here rather than
+* at boot, so `"wordpress:7.1.0"`, which would resolve to `wordpress:wordpress:7.1.0`, is named as a
+* config mistake instead of surfacing as a pull failure seconds into starting a stack.
 */
 const versionSchema = z.string().regex(WORDPRESS_TAG_PATTERN, "must be a WordPress image tag, like \"7.1.0\" or \"7.1.0-php8.3-apache\" (no \"wordpress:\" prefix)");
+/**
+* A key that moved in the config redesign. It accepts only `undefined`, so an absent key passes and a
+* present one fails validation with a message naming where it went: a hard cutover with no silent
+* fallback. {@link loadConfigFile} surfaces the message through `z.prettifyError`.
+*/
+const removedKey = (message) => z.undefined({ error: message }).optional();
+const dirSchema = z.union([z.string(), z.object({
+	server: z.string().optional(),
+	contract: z.string().optional(),
+	introspection: z.string().optional()
+})]);
+const devStackSchema = z.object({
+	enable: z.boolean().optional(),
+	port: z.number().int().positive().optional(),
+	version: versionSchema.optional(),
+	dbPort: z.number().int().positive().optional(),
+	fixtures: z.array(fixtureSchema).optional()
+});
+const testStackSchema = z.object({
+	enable: z.boolean().optional(),
+	inherit: z.boolean().optional(),
+	port: z.number().int().positive().optional(),
+	version: versionSchema.optional(),
+	fixtures: z.array(fixtureSchema).optional(),
+	packageManager: z.enum([
+		"npm",
+		"pnpm",
+		"yarn",
+		"bun"
+	]).optional(),
+	command: z.string().optional()
+});
+const localSchema = z.union([z.boolean(), z.object({
+	enable: z.boolean().optional(),
+	name: z.string().optional(),
+	worktrees: z.boolean().optional(),
+	dev: devStackSchema.optional(),
+	test: testStackSchema.optional()
+})]);
 /** Runtime shape of `kizlo.config.*` — mirrors {@link KizloGlobalConfig}. */
 const configSchema = z.object({
-	dir: z.string().optional(),
+	dir: dirSchema.optional(),
 	alias: z.string().optional(),
-	name: z.string().optional(),
-	worktrees: z.boolean().optional(),
-	wordpressClientDir: z.string().optional(),
-	dev: z.object({
-		local: z.boolean().optional(),
-		port: z.number().int().positive().optional(),
-		version: versionSchema.optional(),
-		dbPort: z.number().int().positive().optional(),
-		fixtures: z.array(fixtureSchema).optional()
-	}).optional(),
-	test: z.object({
-		local: z.boolean().optional(),
-		port: z.number().int().positive().optional(),
-		version: versionSchema.optional(),
-		fixtures: z.array(fixtureSchema).optional(),
-		packageManager: z.enum([
-			"npm",
-			"pnpm",
-			"yarn",
-			"bun"
-		]).optional(),
-		command: z.string().optional()
-	}).optional()
+	local: localSchema.optional(),
+	wordpressClientDir: removedKey("`wordpressClientDir` has been removed. Use `dir: { introspection }` instead."),
+	name: removedKey("`name` is no longer a config root key. Move it under `local.name`."),
+	worktrees: removedKey("`worktrees` is no longer a config root key. Move it under `local.worktrees`."),
+	dev: removedKey("`dev` is no longer a config root key. Move it under `local.dev`."),
+	test: removedKey("`test` is no longer a config root key. Move it under `local.test`.")
 });
+/** Normalize `local` (absent, `true`, `false`, or the object form) into one shape the resolvers read. */
+function resolveLocal(fileConfig) {
+	const local = fileConfig?.local;
+	if (local === true) return {
+		enabled: true,
+		dev: {},
+		test: {}
+	};
+	if (!local) return {
+		enabled: false,
+		dev: {},
+		test: {}
+	};
+	return {
+		enabled: local.enable !== false,
+		name: local.name,
+		worktrees: local.worktrees,
+		dev: local.dev ?? {},
+		test: local.test ?? {}
+	};
+}
 const CONFIG_FILES = [
 	"kizlo.config.ts",
 	"kizlo.config.js",
@@ -52,6 +95,12 @@ const CONFIG_FILES = [
 const DEFAULT_DEV_PORT = 8080;
 const DEFAULT_DEV_DB_PORT = 3307;
 const DEFAULT_TEST_PORT = 8889;
+/** The generated introspection artifact's filename, written under its resolved directory. */
+const INTROSPECTION_FILE = "introspection.ts";
+/** Strip a leading `./` and trailing slashes so a config path joins cleanly. */
+function normalizeDir(value) {
+	return value.replace(/^\.\//, "").replace(/\/+$/, "");
+}
 async function loadConfigFile(cwd) {
 	const file = CONFIG_FILES.map((name) => path.join(cwd, name)).find((p) => fs.existsSync(p));
 	if (!file) return void 0;
@@ -71,40 +120,56 @@ async function loadConfigFile(cwd) {
 	return result.data;
 }
 /**
-* Resolve the Kizlo server layout from an explicit `dir` — the `--dir` flag or `dir` in
-* `kizlo.config.*`. Returns `undefined` when neither is set: there's no Kizlo server to
-* generate a contract from, so callers skip generation and (for `dev`) run local WordPress
-* alone. There's intentionally no default path — a missing `dir` means "no server", not
-* "look under `lib/kizlo`".
+* Resolve what Kizlo generates and watches from `dir`: the `--dir` flag or `dir` in `kizlo.config.*`.
+* A string is the home Kizlo owns the layout under (sources in `<dir>/server`, generated files under
+* `<dir>/server/generated`); the object form sets `server` / `contract` / `introspection` independently.
+*
+* The introspection is always generated at its resolved path, so a project with no server still gets it.
+* `server` is present only when `dir` resolves a server path (the string form always does, the object
+* form only when `server` is set), and its absence means there is nothing to watch and no contract to
+* build. Returns `undefined` only when nothing at all is configured (no `dir`, or an object naming
+* neither a server nor an introspection path): there is then nothing to generate.
 */
 async function resolveConfig(cwd, flags) {
 	const fileConfig = await loadConfigFile(cwd);
 	const raw = flags?.dir ?? fileConfig?.dir;
-	if (!raw) return void 0;
-	const dir = raw.replace(/^\.\//, "").replace(/\/+$/, "");
-	const serverDir = path.join(dir, "server");
-	const generatedDir = path.join(serverDir, "generated");
+	if (raw === void 0) return void 0;
+	if (typeof raw === "string") {
+		const home = normalizeDir(raw);
+		const serverDir$1 = path.join(home, "server");
+		const contractDir$1 = path.join(serverDir$1, "generated");
+		return {
+			cwd,
+			server: {
+				dir: serverDir$1,
+				entry: path.join(serverDir$1, "index.ts"),
+				contractDir: contractDir$1,
+				contractPath: path.join(contractDir$1, "contract.json"),
+				barrelPath: path.join(contractDir$1, "index.ts")
+			},
+			introspectionPath: path.join(contractDir$1, INTROSPECTION_FILE),
+			introspectionMetaPath: INTROSPECTION_META_REL
+		};
+	}
+	const serverDir = raw.server ? normalizeDir(raw.server) : void 0;
+	const contractDir = serverDir ? raw.contract ? normalizeDir(raw.contract) : path.join(serverDir, "generated") : void 0;
+	const server = serverDir && contractDir ? {
+		dir: serverDir,
+		entry: path.join(serverDir, "index.ts"),
+		contractDir,
+		contractPath: path.join(contractDir, "contract.json"),
+		barrelPath: path.join(contractDir, "index.ts")
+	} : void 0;
+	const introspectionDir = raw.introspection ? normalizeDir(raw.introspection) : contractDir;
+	if (!introspectionDir) return void 0;
 	return {
 		cwd,
-		dir,
-		serverDir,
-		serverEntry: path.join(serverDir, "index.ts"),
-		generatedDir,
-		contractPath: path.join(generatedDir, "contract.json"),
-		barrelPath: path.join(generatedDir, "index.ts"),
-		wordpressPath: path.join(generatedDir, "wordpress.ts"),
-		wordpressMetaPath: WORDPRESS_META_REL
+		server,
+		introspectionPath: path.join(introspectionDir, INTROSPECTION_FILE),
+		introspectionMetaPath: INTROSPECTION_META_REL
 	};
 }
 /**
-* The directory `wordpress.ts` is written to for a workspace with no Kizlo server, from `wordpressClientDir`
-* in `kizlo.config.*`. Resolved on its own rather than through {@link resolveConfig}, which describes a
-* server layout and returns nothing without `dir` — the two are independent.
-*/
-async function resolveWordPressClientDir(cwd) {
-	return (await loadConfigFile(cwd))?.wordpressClientDir;
-}
-/**
 * Sanitize an arbitrary package/dir name into a valid Docker compose project id:
 * lowercase, `@scope/pkg` → `scope-pkg`, dropping anything outside `[a-z0-9_-]`.
 */
@@ -164,61 +229,62 @@ function stackProject(baseName, kind) {
 	return `kizlo-${baseName}-${kind}`;
 }
 /**
-* Resolve the `test` block from `kizlo.config.*` into concrete values for the
-* `test` command, applying defaults (port 8889, auto-detected package manager)
-* and anchoring the credentials artifact to the config directory.
+* Resolve the test stack (`local.test`) into concrete values for the `test` command, applying defaults
+* (port 8889, auto-detected package manager) and anchoring the credentials artifact to the config
+* directory. `version` and `fixtures` fall back to the dev stack unless `test.inherit` is `false`;
+* `port`, `packageManager`, and `command` are never inherited.
 */
 async function resolveTestConfig(cwd) {
 	const configDir = findConfigDir(cwd);
-	const fileConfig = await loadConfigFile(configDir);
-	const test = fileConfig?.test ?? {};
+	const local = resolveLocal(await loadConfigFile(configDir));
+	const { dev, test } = local;
+	const inherit = test.inherit !== false;
 	return {
 		configDir,
-		local: Boolean(test.local),
+		local: local.enabled && test.enable !== false,
 		project: stackProject(resolveStackName(configDir, {
-			name: fileConfig?.name,
-			worktrees: fileConfig?.worktrees
+			name: local.name,
+			worktrees: local.worktrees
 		}), "test"),
 		command: test.command,
 		port: test.port ?? DEFAULT_TEST_PORT,
-		portExplicit: test.port !== void 0 && !fileConfig?.worktrees,
-		wordpressTag: test.version ?? DEFAULT_WORDPRESS_TAG,
-		fixtures: test.fixtures ?? [],
+		portExplicit: test.port !== void 0 && !local.worktrees,
+		wordpressTag: test.version ?? (inherit ? dev.version : void 0) ?? DEFAULT_WORDPRESS_TAG,
+		fixtures: test.fixtures ?? (inherit ? dev.fixtures : void 0) ?? [],
 		credentialsPath: credentialsPath(cwd),
 		packageManager: test.packageManager ?? await detectPackageManager(configDir) ?? "npm"
 	};
 }
 /**
-* Whether this project runs local WordPress under `kizlo dev` — `dev.local` is `true` in
-* `kizlo.config.*`. When false, `kizlo dev` has nothing to boot and runs the contract watcher alone,
-* the path a project pointing at its own WordPress takes. The flag is written by `create`/`init` when
-* local WordPress is chosen, and lives next to the rest of the `dev` config, so it's committed and
-* survives `kizlo dev reset`.
+* Whether this project runs local WordPress under `kizlo dev`: local is enabled and the dev stack is
+* on (`local.dev.enable !== false`) in `kizlo.config.*`. When false, `kizlo dev` has nothing to boot and
+* runs the contract watcher alone, the path a project pointing at its own WordPress takes. Written by
+* `create`/`init` when local WordPress is chosen, so it's committed and survives `kizlo dev reset`.
 */
 async function usesLocalWordPress(cwd) {
-	const fileConfig = await loadConfigFile(findConfigDir(cwd));
-	return Boolean(fileConfig?.dev?.local);
+	const local = resolveLocal(await loadConfigFile(findConfigDir(cwd)));
+	return local.enabled && local.dev.enable !== false;
 }
 /**
-* Resolve the `dev` block from `kizlo.config.*` into concrete values for the `dev` command, applying
-* defaults (port 8080). The install folder is fixed at `.kizlo/local` — no longer a config choice — so
-* there's nothing required here. Callers gate on {@link usesLocalWordPress} first, since a project
-* without local WordPress runs the watcher alone rather than reaching here.
+* Resolve the dev stack (`local.dev`) into concrete values for the `dev` command, applying defaults
+* (port 8080). The install folder is fixed at `.kizlo/local` (no longer a config choice), so there's
+* nothing required here. Callers gate on {@link usesLocalWordPress} first, since a project without
+* local WordPress runs the watcher alone rather than reaching here.
 */
 async function resolveDevConfig(cwd) {
 	const configDir = findConfigDir(cwd);
-	const fileConfig = await loadConfigFile(configDir);
-	const dev = fileConfig?.dev ?? {};
+	const local = resolveLocal(await loadConfigFile(configDir));
+	const { dev } = local;
 	return {
 		configDir,
 		project: stackProject(resolveStackName(configDir, {
-			name: fileConfig?.name,
-			worktrees: fileConfig?.worktrees
+			name: local.name,
+			worktrees: local.worktrees
 		}), "dev"),
 		port: dev.port ?? DEFAULT_DEV_PORT,
-		portExplicit: dev.port !== void 0 && !fileConfig?.worktrees,
+		portExplicit: dev.port !== void 0 && !local.worktrees,
 		dbPort: dev.dbPort ?? DEFAULT_DEV_DB_PORT,
-		dbPortExplicit: dev.dbPort !== void 0 && !fileConfig?.worktrees,
+		dbPortExplicit: dev.dbPort !== void 0 && !local.worktrees,
 		wordpressTag: dev.version ?? DEFAULT_WORDPRESS_TAG,
 		fixtures: dev.fixtures ?? [],
 		wordpressPath: LOCAL_DIR_REL,
@@ -227,4 +293,4 @@ async function resolveDevConfig(cwd) {
 }
 
 //#endregion
-export { CONFIG_FILES, DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveConfig, resolveDevConfig, resolveStackName, resolveTestConfig, resolveWordPressClientDir, stackProject, usesLocalWordPress };
+export { CONFIG_FILES, DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveConfig, resolveDevConfig, resolveStackName, resolveTestConfig, stackProject, usesLocalWordPress };

package/dist/cli/daemon/generate.js

@@ -1,6 +1,5 @@
 import { generateContract } from "../../shared/contract.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";
@@ -24,7 +23,7 @@ const CONTRACT_BARREL = [
 	`import contractJson from "./contract.json"`,
 	``,
 	`export const contract = contractJson as unknown as typeof procedures`,
-	`export { endpoints, type WordPressClient } from "./wordpress"`,
+	`export { endpoints, type WordPressClient } from "./introspection"`,
 	``
 ].join("\n");
 var LegacyRouterExportError = class extends Error {
@@ -34,13 +33,13 @@ var LegacyRouterExportError = class extends Error {
 	}
 };
 /**
-* `wordpress.ts` before the first generation. WordPress is reachable but untyped until then, so a
+* `introspection.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
-* 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
+* connected. `kizlo dev` / `kizlo generate` replaces this with the real introspection. `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.
 */
-const WORDPRESS_STUB = [
+const INTROSPECTION_STUB = [
 	`import type { WP_Client } from "kizlo"`,
 	``,
 	`export const endpoints = {} as any`,
@@ -51,6 +50,12 @@ const WORDPRESS_STUB = [
 	`\tinterface WordPressClientRegistry {`,
 	`\t\tendpoints: typeof endpoints`,
 	`\t}`,
+	`\tinterface WordPressEndpointRegistry {`,
+	`\t\t[path: string]: any`,
+	`\t}`,
+	`\tinterface WordPressCustomFieldsRegistry {`,
+	`\t\t[path: string]: Record<string, unknown>`,
+	`\t}`,
 	`}`,
 	``
 ].join("\n");
@@ -117,8 +122,8 @@ function formatDiagnostic(diagnostic) {
 * partial contract is worth is the generator's call rather than the transport's. Taking it is the
 * default: a third-party plugin's broken declaration then costs its own routes and nothing else,
 * where refusing the document costs the project every route that still works, for a mistake in code
-* it does not own. Strict generation makes the opposite trade for CI, where a client silently short
-* of routes typechecks clean and ships the gap.
+* it does not own. Strict generation makes the opposite trade for CI, where an introspection silently
+* short of routes typechecks clean and ships the gap.
 */
 var PartialContractError = class extends Error {
 	excluded;
@@ -149,7 +154,7 @@ function reportDiagnostics(document, strict) {
 	const excluded = new Set(document.diagnostics.filter((diagnostic) => diagnostic.type === "error").map(diagnosticLocation));
 	if (!excluded.size) return;
 	if (strict) throw new PartialContractError(excluded.size);
-	log.warn(`Generating without the ${excluded.size} excluded ${excluded.size === 1 ? "contribution" : "contributions"} above. Their routes and types are missing from the client; \`kizlo generate --strict\` refuses the contract instead.`);
+	log.warn(`Generating without the ${excluded.size} excluded ${excluded.size === 1 ? "contribution" : "contributions"} above. Their routes and types are missing from the introspection; \`kizlo generate --strict\` refuses the contract instead.`);
 }
 /**
 * Plugin versions already named as outdated. `kizlo dev` refetches every few seconds, and the answer
@@ -183,74 +188,69 @@ async function fetchDocument(cwd, options, etag) {
 	return result;
 }
 /**
-* Produce the WordPress client without writing it or its ETag cache. Health checks use this to ask
+* Produce the introspection source without writing it or its ETag cache. Health checks use this to ask
 * the same generator as `kizlo generate` what should be on disk, while leaving a contributor's
 * checkout untouched. Callers choose strictness just as generation does.
 */
-async function generateWordPressSource(cwd, options = {}) {
+async function generateIntrospectionSource(cwd, options = {}) {
 	const result = await fetchDocument(cwd, options);
 	if (!result?.document) throw new Error("WordPress introspection returned no document.");
 	const generated = generateWordPressModule(result.document);
 	await assertGeneratedClientCompiles(generated);
 	return generated.source;
 }
-async function generateWordPressOnce(cfg, options = {}) {
-	const etag = readWordPressMeta(path.resolve(cfg.cwd, cfg.wordpressMetaPath), path.resolve(cfg.cwd, cfg.wordpressPath))?.etag;
-	const result = await fetchDocument(cfg.cwd, options, etag);
-	if (!result?.document) return "unchanged";
-	const generated = generateWordPressModule(result.document);
-	await assertGeneratedClientCompiles(generated);
-	writeGeneratedWordPress(cfg, generated.source, wordPressMeta(result.etag, result.document.hash));
-	return "generated";
-}
 /**
-* Write `<dir>/wordpress.ts` once for a whole workspace. Every package that ships procedures compiles
-* against the same file, so there is one description of WordPress in the repo rather than one per
-* package drifting apart. One shape too: a package that only wants the types today still gets the
-* class, so reaching for the runtime later needs no regeneration.
+* Write `introspection.ts` at its resolved path, revalidating against the ETag cache. The one place
+* the introspection reaches disk, whether or not the project has a server: a server-backed app writes
+* it under `generated/`, and a package that only ships procedures writes it at its own `dir.introspection`.
 */
-async function generateWorkspaceClientOnce(cwd, dir, options = {}) {
-	const file = path.resolve(cwd, dir, "wordpress.ts");
-	const metaPath = path.resolve(cwd, WORDPRESS_CLIENT_META_REL);
-	const result = await fetchDocument(cwd, options, readWordPressMeta(metaPath, file)?.etag);
+async function generateIntrospectionOnce(cfg, options = {}) {
+	const file = path.resolve(cfg.cwd, cfg.introspectionPath);
+	const metaPath = path.resolve(cfg.cwd, cfg.introspectionMetaPath);
+	const result = await fetchDocument(cfg.cwd, options, readWordPressMeta(metaPath, file)?.etag);
 	if (!result?.document) return "unchanged";
 	const generated = generateWordPressModule(result.document);
 	await assertGeneratedClientCompiles(generated);
-	const contents = generated.source;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
 	fs.mkdirSync(path.dirname(metaPath), { recursive: true });
+	atomicWrite(file, generated.source);
 	atomicWrite(metaPath, wordPressMeta(result.etag, result.document.hash));
-	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === contents) return "unchanged";
-	fs.mkdirSync(path.dirname(file), { recursive: true });
-	atomicWrite(file, contents);
 	return "generated";
 }
-function writeGeneratedWordPress(cfg, client, meta) {
-	const metaPath = path.resolve(cfg.cwd, cfg.wordpressMetaPath);
-	fs.mkdirSync(path.resolve(cfg.cwd, cfg.generatedDir), { recursive: true });
-	fs.mkdirSync(path.dirname(metaPath), { recursive: true });
-	atomicWrite(path.resolve(cfg.cwd, cfg.wordpressPath), client);
-	atomicWrite(metaPath, meta);
-}
 /**
-* Loads the Kizlo server, builds its contract, and writes `contract.json` and
-* the generated barrel. Returns false when the entry has no Kizlo server.
+* Generate everything `dir` resolves: the introspection always, plus the contract and barrel when a
+* server is present. The server is loaded before the introspection is fetched, so a legacy `router`
+* export is named as a migration error even with WordPress unreachable; a server whose entry exports no
+* `procedures` still gets its introspection, and reports `contract: "empty"`.
 */
 async function generateOnce(cfg, options = {}) {
 	loadEnvFiles(cfg.cwd);
-	const entry = path.resolve(cfg.cwd, cfg.serverEntry);
-	const server = await importIgnoringVirtualModules(cfg.cwd, entry);
-	if (!server.procedures) {
-		if (server.router) throw new LegacyRouterExportError(cfg.serverEntry);
-		return false;
+	let procedures;
+	if (cfg.server) {
+		const entry = path.resolve(cfg.cwd, cfg.server.entry);
+		const server = await importIgnoringVirtualModules(cfg.cwd, entry);
+		if (!server.procedures && server.router) throw new LegacyRouterExportError(cfg.server.entry);
+		procedures = server.procedures;
 	}
-	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);
-	atomicWrite(path.resolve(cfg.cwd, cfg.barrelPath), CONTRACT_BARREL);
-	if (wordpress === "generated") log.success("WordPress client generated");
-	return true;
+	const introspection = await generateIntrospectionOnce(cfg, options);
+	if (!cfg.server) return {
+		introspection,
+		contract: "none"
+	};
+	if (!procedures) return {
+		introspection,
+		contract: "empty"
+	};
+	const contract = JSON.stringify(await generateContract(procedures));
+	fs.mkdirSync(path.resolve(cfg.cwd, cfg.server.contractDir), { recursive: true });
+	atomicWrite(path.resolve(cfg.cwd, cfg.server.contractPath), contract);
+	atomicWrite(path.resolve(cfg.cwd, cfg.server.barrelPath), CONTRACT_BARREL);
+	if (introspection === "generated") log.success("WordPress introspection generated");
+	return {
+		introspection,
+		contract: "built"
+	};
 }
 
 //#endregion
-export { CONTRACT_BARREL, PartialContractError, WORDPRESS_STUB, generateOnce, generateWordPressOnce, generateWordPressSource, generateWorkspaceClientOnce, reportGenerationError };
+export { CONTRACT_BARREL, INTROSPECTION_STUB, PartialContractError, generateIntrospectionOnce, generateIntrospectionSource, generateOnce, reportGenerationError };