kizlo 0.20.0 → 0.20.2

package/dist/cli/commands/_wiring.js

@@ -10,7 +10,8 @@ import * as p from "@clack/prompts";
 //#region src/cli/commands/_wiring.ts
 /** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, the import-alias preference, and,
 *  when local WordPress is chosen, `local: true` so `kizlo dev` and `kizlo test` boot the fixed
-*  `.kizlo/local` install (both stacks on with defaults; the object form is for configuring them). The
+*  `.kizlo/local` install (both stacks on with defaults; the object form configures them and turns each
+*  on with its own `enable: true`). The
 *  alias is always written (`""` for relative imports included) so it records a made decision a later
 *  `kizlo init` reads back instead of prompting for it again. The alias is written in its canonical `@/`
 *  form (never a bare `@`) so it reads like the imports it produces. */

package/dist/cli/commands/generate.js

@@ -1,5 +1,5 @@
 import { log } from "../daemon/logger.js";
-import { resolveConfig } from "../daemon/config.js";
+import { resolveConfig, resolveWatchCredentials } from "../daemon/config.js";
 import { PartialContractError, generateOnce, reportGenerationError } from "../daemon/generate.js";
 import { testWordPressCredentials } from "./_test-wordpress.js";
 import path from "node:path";
@@ -38,18 +38,31 @@ const generate = defineCommand({
 	async run({ args }) {
 		const cwd = process.cwd();
 		const strict = args.strict === true;
-		let credentials;
+		let options;
 		if (args.test) try {
-			credentials = await testWordPressCredentials(cwd);
+			options = {
+				credentials: await testWordPressCredentials(cwd),
+				strict
+			};
 		} catch (error) {
 			log.error(error instanceof Error ? error.message : String(error));
 			process.exitCode = 1;
 			return;
 		}
-		const options = {
-			credentials,
-			strict
-		};
+		else {
+			const credentials = await resolveWatchCredentials(cwd);
+			if (credentials) options = {
+				credentials,
+				strict
+			};
+			else {
+				log.info("No WordPress connection configured; generating the contract only, introspection skipped.");
+				options = {
+					skipIntrospection: true,
+					strict
+				};
+			}
+		}
 		const cfg = await resolveConfig(cwd, { dir: args.dir });
 		if (!cfg) {
 			log.info("Nothing to generate. Set `dir` in kizlo.config.ts or pass --dir.");
@@ -66,6 +79,7 @@ const generate = defineCommand({
 			process.exit(1);
 		}
 		if (result.contract === "none") {
+			if (result.introspection === "skipped") return;
 			const file = path.resolve(cwd, cfg.introspectionPath);
 			log.success(`WordPress introspection ${result.introspection === "generated" ? "written to" : "already current at"} ${file}`);
 			return;

package/dist/cli/daemon/config.js

@@ -1,7 +1,9 @@
+import { integrationEnv, resolveWordPressConnection, wordPressConnectionComplete } from "../../kizlo.js";
 import { DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL } from "../wp/constants.js";
 import { credentialsPath, findConfigDir } from "../wp/utils.js";
+import { node } from "../../integrations/node/integration.js";
 import { log } from "./logger.js";
-import { detectPackageManager } from "../utils.js";
+import { detectPackageManager, loadEnvFiles } from "../utils.js";
 import { WORDPRESS_TAG_PATTERN } from "../wp/version.js";
 import { importIgnoringVirtualModules } from "./jiti.js";
 import z from "zod/v4";
@@ -66,21 +68,31 @@ const configSchema = z.object({
 	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. */
+/**
+* Normalize `local` (absent, `true`, `false`, or the object form) into one shape the resolvers read.
+* A stack is off unless its own `enable: true` is set; `local: true` is the shorthand that turns both on.
+*/
 function resolveLocal(fileConfig) {
 	const local = fileConfig?.local;
 	if (local === true) return {
 		enabled: true,
+		devEnabled: true,
+		testEnabled: true,
 		dev: {},
 		test: {}
 	};
 	if (!local) return {
 		enabled: false,
+		devEnabled: false,
+		testEnabled: false,
 		dev: {},
 		test: {}
 	};
+	const enabled = local.enable !== false;
 	return {
-		enabled: local.enable !== false,
+		enabled,
+		devEnabled: enabled && local.dev?.enable === true,
+		testEnabled: enabled && local.test?.enable === true,
 		name: local.name,
 		worktrees: local.worktrees,
 		dev: local.dev ?? {},
@@ -241,7 +253,7 @@ async function resolveTestConfig(cwd) {
 	const inherit = test.inherit !== false;
 	return {
 		configDir,
-		local: local.enabled && test.enable !== false,
+		local: local.testEnabled,
 		project: stackProject(resolveStackName(configDir, {
 			name: local.name,
 			worktrees: local.worktrees
@@ -256,14 +268,27 @@ async function resolveTestConfig(cwd) {
 	};
 }
 /**
-* 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`.
+* Whether this project runs local WordPress under `kizlo dev`: the `local` block is enabled and the dev
+* stack is turned on with `local.dev.enable: true` (or `local: 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. Written by `create`/`init` when local WordPress is chosen, so it's committed and
+* survives `kizlo dev reset`.
 */
 async function usesLocalWordPress(cwd) {
-	const local = resolveLocal(await loadConfigFile(findConfigDir(cwd)));
-	return local.enabled && local.dev.enable !== false;
+	return resolveLocal(await loadConfigFile(findConfigDir(cwd))).devEnabled;
+}
+/**
+* WordPress credentials for the dev/generate watcher, or `undefined` when there is nothing to introspect:
+* the active profile is `local` but no local dev stack is enabled, or the active profile's connection
+* envs are incomplete. Callers then generate the contract with introspection skipped rather than fetching
+* from a WordPress that is not there. Unlike {@link resolveWordPressConnection}, this never throws.
+*/
+async function resolveWatchCredentials(cwd) {
+	loadEnvFiles(cwd);
+	const env = integrationEnv([node()]);
+	if (env("mode")?.trim() === "local" && !await usesLocalWordPress(cwd)) return void 0;
+	if (!wordPressConnectionComplete(env)) return void 0;
+	return resolveWordPressConnection(env).credentials;
 }
 /**
 * Resolve the dev stack (`local.dev`) into concrete values for the `dev` command, applying defaults
@@ -293,4 +318,4 @@ async function resolveDevConfig(cwd) {
 }
 
 //#endregion
-export { CONFIG_FILES, DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveConfig, resolveDevConfig, resolveStackName, resolveTestConfig, stackProject, usesLocalWordPress };
+export { CONFIG_FILES, DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveConfig, resolveDevConfig, resolveStackName, resolveTestConfig, resolveWatchCredentials, stackProject, usesLocalWordPress };

package/dist/cli/daemon/generate.js

@@ -205,6 +205,7 @@ async function generateIntrospectionSource(cwd, options = {}) {
 * it under `generated/`, and a package that only ships procedures writes it at its own `dir.introspection`.
 */
 async function generateIntrospectionOnce(cfg, options = {}) {
+	if (options.skipIntrospection) return "skipped";
 	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);

package/dist/cli/daemon/watch.js

@@ -1,8 +1,5 @@
-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 } from "./config.js";
+import { resolveConfig, resolveWatchCredentials } from "./config.js";
 import { IntrospectionFetchError } from "../../wordpress/fetch-introspection.js";
 import { generateIntrospectionOnce, generateOnce, reportGenerationError } from "./generate.js";
 import { acquire, lockPath, release } from "./lock.js";
@@ -17,9 +14,9 @@ function debounce(fn, delay) {
 		timer = setTimeout(() => void fn(...args), delay);
 	});
 }
-async function regenerate(cfg, credentials) {
+async function regenerate(cfg, options) {
 	try {
-		const result = await generateOnce(cfg, { credentials });
+		const result = await generateOnce(cfg, options);
 		if (result.contract === "built") log.success("Contract updated");
 		else if (result.contract === "empty" && cfg.server) log.warn(`No Kizlo server found in ${cfg.server.entry}`);
 	} catch (error) {
@@ -27,13 +24,13 @@ async function regenerate(cfg, credentials) {
 	}
 }
 /** Watches the server directory and regenerates the contract on change. Only called when a server is present. */
-async function watch(cfg, server, credentials) {
+async function watch(cfg, server, options) {
 	const watcher = new FSWatcher({
 		persistent: true,
 		ignoreInitial: true,
 		ignored: path.resolve(cfg.cwd, server.contractDir)
 	});
-	const onChange = debounce(() => regenerate(cfg, credentials), 300);
+	const onChange = debounce(() => regenerate(cfg, options), 300);
 	watcher.add(path.resolve(cfg.cwd, server.dir));
 	watcher.on("all", () => void onChange());
 	return watcher;
@@ -139,25 +136,26 @@ async function startWatcher(cwd, opts) {
 			log.info("skipping the contract generation.");
 			return;
 		}
-		loadEnvFiles(cwd);
-		const { credentials } = resolveWordPressConnection(integrationEnv([node()]));
+		const credentials = await resolveWatchCredentials(cwd);
+		const options = credentials ? { credentials } : { skipIntrospection: true };
+		if (!credentials) log.info("No WordPress connection configured; running the contract watcher only, introspection skipped.");
 		try {
-			const result = await generateOnce(cfg, { credentials });
+			const result = await generateOnce(cfg, options);
 			if (result.contract === "built") log.success("Contract generated");
 			else if (result.contract === "empty" && cfg.server) log.warn(`No Kizlo server found in ${cfg.server.entry}`);
 			else if (result.introspection === "generated") log.success("WordPress introspection generated");
 		} catch (error) {
 			reportGenerationError("Failed to generate the Kizlo contract:", error);
 		}
-		const watcher = cfg.server ? await watch(cfg, cfg.server, credentials) : void 0;
-		const wordpressRefresh = refreshWordPress(cfg, credentials, opts?.stack);
+		const watcher = cfg.server ? await watch(cfg, cfg.server, options) : void 0;
+		const wordpressRefresh = credentials ? refreshWordPress(cfg, credentials, opts?.stack) : void 0;
 		let stopped = false;
 		handedOver = true;
 		return () => {
 			if (stopped) return;
 			stopped = true;
 			release(lock);
-			clearInterval(wordpressRefresh);
+			if (wordpressRefresh) clearInterval(wordpressRefresh);
 			watcher?.close();
 		};
 	} finally {

package/dist/cli/wp/compose/apache-listen.conf

@@ -0,0 +1,15 @@
+# Kizlo local WordPress — make same-site server requests reach Apache.
+#
+# WordPress builds internal, server-side requests (e.g. a plugin calling its own
+# admin_url()) against the browser-facing URL, which carries the *published* host
+# port — say http://localhost:8890. Inside the container that request loops back to
+# localhost:8890, but Apache only listens on 80 (Docker maps the host port to 80),
+# so the call fails with cURL error 7 and the plugin stalls.
+#
+# Listening on the published port as well makes localhost:<port> resolve inside the
+# container exactly as it does from the browser. Apache keeps its port-80 listener
+# for Docker's port mapping and the health check; this only adds a second one.
+#
+# WP_PORT is passed into the wordpress service by the CLI (and defaulted in the base
+# Compose file), so Apache expands ${WP_PORT} from the container environment.
+Listen ${WP_PORT}

package/dist/cli/wp/compose/docker-compose.test.ts

@@ -0,0 +1,66 @@
+import fs from "node:fs"
+import { describe, expect, test } from "vitest"
+import { parse } from "yaml"
+import { APACHE_LISTEN_CONF, COMPOSE_FILE, UPLOADS_INI } from "../constants"
+
+interface Service {
+	environment?: Record<string, string>
+	ports?: string[]
+	volumes?: string[]
+}
+
+const wordpress = (): Service => parse(fs.readFileSync(COMPOSE_FILE, "utf8")).services.wordpress
+
+/** Parse a `key=value` INI (comments/blank lines dropped) into a lookup. */
+function ini(file: string): Record<string, string> {
+	const out: Record<string, string> = {}
+	for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+		const trimmed = line.trim()
+		if (!trimmed || trimmed.startsWith(";")) continue
+		const eq = trimmed.indexOf("=")
+		if (eq !== -1) out[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim()
+	}
+	return out
+}
+
+/** PHP size shorthand (`2G`, `2100M`, `512K`) to bytes. */
+function bytes(size: string): number {
+	const match = /^(\d+)([KMG]?)$/i.exec(size)
+	if (!match) throw new Error(`not a PHP size: ${size}`)
+	const scale = { "": 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3 }[match[2]?.toUpperCase() ?? ""] ?? 1
+	return Number(match[1]) * scale
+}
+
+describe("base compose wordpress service", () => {
+	test("receives the published port so Apache can listen on it", () => {
+		// Defaulted to the same value as the port mapping so a standalone `up` still parses.
+		// The `${...}` here are literal Compose interpolation tokens, not JS templates.
+		// biome-ignore lint/suspicious/noTemplateCurlyInString: literal Compose interpolation
+		expect(wordpress().environment?.WP_PORT).toBe("${WP_PORT:-8080}")
+		// biome-ignore lint/suspicious/noTemplateCurlyInString: literal Compose interpolation
+		expect(wordpress().ports).toContain("${WP_PORT:-8080}:80")
+	})
+
+	test("mounts both local-only config assets read-only", () => {
+		const volumes = wordpress().volumes ?? []
+		expect(volumes).toContain("./uploads.ini:/usr/local/etc/php/conf.d/zz-kizlo-uploads.ini:ro")
+		expect(volumes).toContain("./apache-listen.conf:/etc/apache2/conf-enabled/zz-kizlo-listen.conf:ro")
+	})
+})
+
+describe("uploads.ini", () => {
+	test("raises the upload ceiling to 2 GB", () => {
+		expect(ini(UPLOADS_INI).upload_max_filesize).toBe("2G")
+	})
+
+	test("allows POST overhead above the file limit for the multipart envelope", () => {
+		const values = ini(UPLOADS_INI)
+		expect(bytes(values.post_max_size ?? "")).toBeGreaterThan(bytes(values.upload_max_filesize ?? ""))
+	})
+})
+
+describe("apache-listen.conf", () => {
+	test("listens on the injected published port", () => {
+		expect(fs.readFileSync(APACHE_LISTEN_CONF, "utf8")).toMatch(/^\s*Listen\s+\$\{WP_PORT\}\s*$/m)
+	})
+})

package/dist/cli/wp/compose/docker-compose.yml

@@ -40,6 +40,11 @@ services:
       WORDPRESS_DB_NAME: ${MYSQL_DATABASE:-wordpress}
       WORDPRESS_DB_USER: ${MYSQL_USER:-wordpress}
       WORDPRESS_DB_PASSWORD: ${MYSQL_PASSWORD:-wppass}
+      # Published host port, handed to Apache so `apache-listen.conf` can add a
+      # second listener on it (see that file). Defaulted here to match the port
+      # mapping above so a standalone `docker compose up` still parses the config;
+      # every path through the CLI supplies the resolved port as WP_PORT.
+      WP_PORT: ${WP_PORT:-8080}
       # The wordpress image eval()s WORDPRESS_CONFIG_EXTRA at runtime, and Compose
       # interpolates `$` in this file first — so every PHP variable below is written
       # `$$` to survive Compose and reach PHP as a literal `$`.
@@ -56,6 +61,11 @@ services:
         }
     volumes:
       - wp_data:/var/www/html
+      # Real PHP upload limits and the extra Apache listener, both shipped next to
+      # this file (relative binds resolve against the compose file's directory) and
+      # mounted read-only. In the base compose so dev and test stacks both get them.
+      - ./uploads.ini:/usr/local/etc/php/conf.d/zz-kizlo-uploads.ini:ro
+      - ./apache-listen.conf:/etc/apache2/conf-enabled/zz-kizlo-listen.conf:ro
     healthcheck:
       # wp-login.php always returns 200 unauthenticated; /wp-json can be gated to 401
       # by plugins, so it's not a reliable liveness probe.

package/dist/cli/wp/compose/uploads.ini

@@ -0,0 +1,12 @@
+; Kizlo local WordPress — raise PHP's upload ceiling for large imports.
+;
+; PHP rejects an oversized request before WordPress (or an upload plugin) ever
+; sees it, so a WordPress hook that only changes the *displayed* limit is not
+; enough. These are the real server limits the local stacks enforce.
+;
+; post_max_size is deliberately larger than upload_max_filesize: a file upload
+; arrives as a multipart POST, so the whole request is a little bigger than the
+; file itself. 2100M leaves headroom above the 2G (2048M) file limit for that
+; envelope. Nothing else (memory_limit, execution time) is touched.
+upload_max_filesize=2G
+post_max_size=2100M

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

@@ -24,6 +24,10 @@ declare function kizloRelease(slug: string): string;
 declare const COMPOSE_FILE: string;
 /** PHP OPcache config, shipped alongside this module and bind-mounted into the local WordPress. */
 declare const OPCACHE_INI: string;
+/** PHP upload-limit config, shipped alongside this module and bind-mounted into the local WordPress. */
+declare const UPLOADS_INI: string;
+/** Apache extra-listener config, shipped alongside this module and bind-mounted into the local WordPress. */
+declare const APACHE_LISTEN_CONF: string;
 /** Linux-only entrypoint that retags www-data to the host user (see the script for why). */
 declare const REMAP_ENTRYPOINT: string;
 declare const CONFIG_FILES: string[];
@@ -54,4 +58,4 @@ declare const DEFAULT_PLUGINS: PluginSource[];
 declare const TEST_ADMIN: Omit<TestAdminUser, "id" | "applicationPassword">;
 declare const TEST_USER: Omit<TestUser, "id">;
 //#endregion
-export { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease };
+export { APACHE_LISTEN_CONF, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, UPLOADS_INI, githubRelease, kizloRelease };

package/dist/cli/wp/constants.js

@@ -30,6 +30,10 @@ const HERE = dirname(fileURLToPath(import.meta.url));
 const COMPOSE_FILE = resolve(HERE, "compose/docker-compose.yml");
 /** PHP OPcache config, shipped alongside this module and bind-mounted into the local WordPress. */
 const OPCACHE_INI = resolve(HERE, "compose/opcache.ini");
+/** PHP upload-limit config, shipped alongside this module and bind-mounted into the local WordPress. */
+const UPLOADS_INI = resolve(HERE, "compose/uploads.ini");
+/** Apache extra-listener config, shipped alongside this module and bind-mounted into the local WordPress. */
+const APACHE_LISTEN_CONF = resolve(HERE, "compose/apache-listen.conf");
 /** Linux-only entrypoint that retags www-data to the host user (see the script for why). */
 const REMAP_ENTRYPOINT = resolve(HERE, "compose/remap-entrypoint.sh");
 const CONFIG_FILES = [
@@ -81,4 +85,4 @@ const TEST_USER = {
 };
 
 //#endregion
-export { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease };
+export { APACHE_LISTEN_CONF, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, UPLOADS_INI, githubRelease, kizloRelease };

package/dist/config.d.ts

@@ -20,8 +20,9 @@ type KizloDir = string | {
 };
 interface KizloDevConfig {
   /**
-   * Run the dev stack. On by default when local WordPress is enabled; set `false` to keep local
-   * WordPress on for `kizlo test` while `kizlo dev` runs the contract watcher alone.
+   * Run the dev stack under `kizlo dev`. Off unless set to `true`; `local: true` is the shorthand that
+   * turns both stacks on. Leave it off to keep the stack configured while `kizlo dev` runs the contract
+   * watcher alone (for example when only `kizlo test` boots local WordPress).
    */
   enable?: boolean;
   /** Published WP port (default 8080). */
@@ -59,8 +60,9 @@ interface KizloDevConfig {
 }
 interface KizloTestConfig {
   /**
-   * Run the test stack. On by default when local WordPress is enabled; set `false` to keep local
-   * WordPress on for `kizlo dev` while `kizlo test` just runs the project's own test script.
+   * Run the test stack under `kizlo test`. Off unless set to `true`; `local: true` is the shorthand that
+   * turns both stacks on. Leave it off and `kizlo test` just runs the project's own test script without
+   * booting local WordPress.
    */
   enable?: boolean;
   /**
@@ -91,8 +93,9 @@ interface KizloTestConfig {
 }
 interface KizloLocalConfig {
   /**
-   * Enable local Docker WordPress (default `true` in this object form). Set `false` to keep the
-   * stacks configured but off, the same as omitting `local` entirely.
+   * Master switch for local Docker WordPress (default `true` in this object form). Set `false` to keep
+   * the stacks configured but off, the same as omitting `local` entirely. Each stack is still off until
+   * its own `enable: true` — see {@link KizloDevConfig.enable} and {@link KizloTestConfig.enable}.
    */
   enable?: boolean;
   /**
@@ -131,9 +134,9 @@ interface KizloGlobalConfig {
    */
   alias?: string;
   /**
-   * Local Docker WordPress, off unless set. `true` enables both the dev and test stacks with
-   * defaults; the object form enables and configures them, and is where the stack name, the
-   * per-branch `worktrees` toggle, and the two stacks live.
+   * Local Docker WordPress, off unless set. `true` enables both the dev and test stacks with defaults;
+   * the object form configures them, with each stack off until its own `enable: true`, and is where the
+   * stack name, the per-branch `worktrees` toggle, and the two stacks live.
    */
   local?: boolean | KizloLocalConfig;
 }

package/dist/index.d.ts

@@ -30,7 +30,7 @@ import { AnyMiddleware, ExtractMiddlewareContextOutput, InferMiddlewares, Middle
 import { AnyProcedure, AnyProcedureTree, BaseHandlerOptions, ExtractParams, ExtractProcedureByScope, InvocationScope, OpenapiPart, Procedure, ProcedureErrors, ProcedureHandler, ProcedureOptions, ProcedureTreeDepthTuple, ResolveParamsPart, ResolvedSchemaInput, ResolvedSchemaOutput, SchemaIO, buildProcedure, combineDetailed, createProcedure, handleUnexpectedError, schemaType } from "./shared/procedure.js";
 import { AnyIntegration, EnvReader, EnvRecord, EnvSource, ExtractIntegrationProcedures, InferIntegrationProcedures, Integration, IntegrationRequirements, KizloEnv, WordPressEnv, assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv } from "./shared/integration.js";
 import { InferProcedureData, InferProcedureError, InferProcedureInput, InferProcedureResult, KizloErrorUnion, KizloResult, MaybeCallerOptions, ProcedureMethod, ResultClient, createResultClient } from "./shared/result.js";
-import { AnyKizloConfig, CreateKizloOptions, Kizlo, KizloConfig, RootProcedures, S2SClient, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection } from "./kizlo.js";
+import { AnyKizloConfig, CreateKizloOptions, Kizlo, KizloConfig, RootProcedures, S2SClient, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection, wordPressConnectionComplete } from "./kizlo.js";
 import { WEB_MANIFEST_ROUTE, WebManifest, buildWebManifest, createManifestRoute } from "./brand/manifest.js";
 import "./brand/index.js";
 import { KizloClient, KizloClientConfig, createKizloClient } from "./client.js";
@@ -43,4 +43,4 @@ import { ShaAlgorithm, compare, hash, hmac } from "./shared/crypto.js";
 import { Identifier, parseIdentifier } from "./shared/identifier.js";
 import { createOrpcRouter } from "./shared/router.js";
 import { deserializeCurrencyFormat, deserializeListMetadata, emptyList, serializeCurrencyFormat } from "./shared/serialize.js";
-export { ActiveWordPressClient, AnyContext, AnyEventSchema, AnyEvents, AnyIntegration, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureTree, AuthAdapter, AuthGetSession, AuthUser, AuthorsSettings, AuthorsSettingsInput, BaseHandlerOptions, BrandSettings, BrandSettingsInput, COMMON_ERRORS, CONTENT_TYPES, CORE_PROCEDURES, CaptchaAdapter, type Category, type CategoryCustomFields, CategoryCustomFieldsSchema, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CookiesStorage, CoreProcedures, CrawlingSettings, CrawlingSettingsInput, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, EnvReader, EnvRecord, EnvSource, ErrorDefinition, EventHandler, EventHandlerFn, ExtractIntegrationProcedures, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, HeadlessSettings, HeadlessSettingsInput, IconDescriptor, Identifier, IdentifierInput, IdentitySettings, IdentitySettingsInput, InferEventUnion, InferIntegrationProcedures, InferMiddlewares, InferProcedureData, InferProcedureError, InferProcedureInput, InferProcedureResult, Integration, IntegrationRequirements, InvocationScope, JsonValue, Kizlo, KizloClient, KizloClientConfig, KizloConfig, KizloEnv, KizloError, KizloErrorOptions, KizloErrorUnion, KizloResult, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, ManifestIcon, MaybeCallerOptions, MaybeOptionalOptions, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, type Page, type PageCustomFields, PageCustomFieldsSchema, PersonSettings, PersonSettingsInput, PluginSource, type Post, type PostCustomFields, PostCustomFieldsSchema, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureMethod, ProcedureOptions, ProcedureTreeDepthTuple, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedIcons, ResolvedSchemaInput, ResolvedSchemaOutput, ResultClient, Robots, RobotsRule, RootProcedures, S2SClient, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServiceAdapters, SessionFn, Settings, SettingsService, SettleContext, ShaAlgorithm, SiteSettings, SiteSettingsInput, Sitemap, SitemapIndex, SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, SocialProfile, type Tag, type TagCustomFields, TagCustomFieldsSchema, TaxonomySettings, TaxonomySettingsInput, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UploadsSettings, UploadsSettingsInput, VerifyCaptchaFn, VerifyPreviewTokenFn, WEB_MANIFEST_ROUTE, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_CustomFields, WP_CustomFieldsPath, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointError, WP_EndpointInput, WP_EndpointPath, WP_EndpointResult, WP_Error, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_ResponseContentType, WP_Result, WP_Success, WP_TransportFailure, WP_TypedHeaders, WebManifest, WebhookOptions, WebhookSettings, WebhookSettingsInput, WithCommonErrorMap, WordPressClientRegistry, WordPressCredentials, WordPressCustomFieldsRegistry, WordPressEndpointRegistry, WordPressEnv, WordPressTransport, WordPressTransportOptions, WordPressTransportResult, altcha, arkose, assertIntegrationEndpoints, assertIntegrationEnv, authMock, buildProcedure, buildWebManifest, buildWordPressRequest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createGeoAdapter, createIntegration, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createResultClient, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, createWordPressClient, customFieldsSchema, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, integrationEnv, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, mergeServiceAdapters, missingEndpoints, missingEnv, noopAdapter, parseIdentifier, parseSitemapSlug, readEnv, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, resolveWordPressConnection, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, wpEndpoint, xmlResponse };
+export { ActiveWordPressClient, AnyContext, AnyEventSchema, AnyEvents, AnyIntegration, AnyKizloConfig, AnyMiddleware, AnyNestedClient, AnyProcedure, AnyProcedureTree, AuthAdapter, AuthGetSession, AuthUser, AuthorsSettings, AuthorsSettingsInput, BaseHandlerOptions, BrandSettings, BrandSettingsInput, COMMON_ERRORS, CONTENT_TYPES, CORE_PROCEDURES, CaptchaAdapter, type Category, type CategoryCustomFields, CategoryCustomFieldsSchema, CommonErrorCode, CommonErrorLiteral, CommonErrorMap, ConnInfo, ConnInfoFn, ConsoleLogAdapterOptions, ContentType, Context, ContextConfig, Contract, ContractProcedure, CookiesAdapter, CookiesDeleteAll, CookiesGetAll, CookiesSetAll, CookiesStorage, CoreProcedures, CrawlingSettings, CrawlingSettingsInput, CreateKizloOptions, CreateSitemapRouteOptions, CurrencyFormat, DefinedErrorMapLike, DevPluginSource, EnvReader, EnvRecord, EnvSource, ErrorDefinition, EventHandler, EventHandlerFn, ExtractIntegrationProcedures, ExtractMiddlewareContextOutput, ExtractParams, ExtractProcedureByScope, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, GeoAdapter, GeoGetConnInfo, HTTPMethod, HeadlessSettings, HeadlessSettingsInput, IconDescriptor, Identifier, IdentifierInput, IdentitySettings, IdentitySettingsInput, InferEventUnion, InferIntegrationProcedures, InferMiddlewares, InferProcedureData, InferProcedureError, InferProcedureInput, InferProcedureResult, Integration, IntegrationRequirements, InvocationScope, JsonValue, Kizlo, KizloClient, KizloClientConfig, KizloConfig, KizloEnv, KizloError, KizloErrorOptions, KizloErrorUnion, KizloResult, LIST_ORDER, List, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, LocalPlugin, LogLevel, LogPayload, Logger, LoggerAdapter, ManifestIcon, MaybeCallerOptions, MaybeOptionalOptions, Middleware, MiddlewareHandler, MiddlewareNextFn, MiddlewareOptions, MiddlewareResult, OpenapiPart, OrganizationFounder, OrganizationSettings, OrganizationSettingsInput, type Page, type PageCustomFields, PageCustomFieldsSchema, PersonSettings, PersonSettingsInput, PluginSource, type Post, type PostCustomFields, PostCustomFieldsSchema, PostStatusDefinition, PostTypeSettings, PostTypeSettingsInput, PreviewTokenData, PreviewTokenPayload, Procedure, ProcedureContext, ProcedureErrors, ProcedureHandler, ProcedureMethod, ProcedureOptions, ProcedureTreeDepthTuple, RedirectInput, RedirectStatus, ResolveParamsPart, ResolvedIcons, ResolvedSchemaInput, ResolvedSchemaOutput, ResultClient, Robots, RobotsRule, RootProcedures, S2SClient, SITEMAP_BASE, SITEMAP_INDEX_SLUG, SchemaIO, SeedContext, Seo, SeoHead, SeoSchema, ServiceAdapters, SessionFn, Settings, SettingsService, SettleContext, ShaAlgorithm, SiteSettings, SiteSettingsInput, Sitemap, SitemapIndex, SitemapIndexEntry, SitemapList, SitemapRouteExtra, SitemapUrl, SitemapUrlImage, SitemapUrlList, SocialProfile, type Tag, type TagCustomFields, TagCustomFieldsSchema, TaxonomySettings, TaxonomySettingsInput, TestAdminUser, TestCredentials, TestUser, ThrowableErrorFn, ThrowableErrorMap, UploadsSettings, UploadsSettingsInput, VerifyCaptchaFn, VerifyPreviewTokenFn, WEB_MANIFEST_ROUTE, WPK_RobotRule, WPK_Robots, WPK_Seo, WPK_Sitemap, WPK_SitemapUrl, WPK_SitemapUrlImage, WP_CallOptions, WP_Client, WP_CommonErrorCode, WP_CurrencyFormat, WP_CustomFields, WP_CustomFieldsPath, WP_Endpoint, WP_EndpointData, WP_EndpointDefinition, WP_EndpointError, WP_EndpointInput, WP_EndpointPath, WP_EndpointResult, WP_Error, WP_ErrorData, WP_Failure, WP_List, WP_ListMetadata, WP_RequestBuild, WP_RequestContentType, WP_RequestInput, WP_RequestMethod, WP_ResponseContentType, WP_Result, WP_Success, WP_TransportFailure, WP_TypedHeaders, WebManifest, WebhookOptions, WebhookSettings, WebhookSettingsInput, WithCommonErrorMap, WordPressClientRegistry, WordPressCredentials, WordPressCustomFieldsRegistry, WordPressEndpointRegistry, WordPressEnv, WordPressTransport, WordPressTransportOptions, WordPressTransportResult, altcha, arkose, assertIntegrationEndpoints, assertIntegrationEnv, authMock, buildProcedure, buildWebManifest, buildWordPressRequest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createGeoAdapter, createIntegration, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createResultClient, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, createWordPressClient, customFieldsSchema, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, integrationEnv, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, mergeServiceAdapters, missingEndpoints, missingEnv, noopAdapter, parseIdentifier, parseSitemapSlug, readEnv, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, resolveWordPressConnection, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, wordPressConnectionComplete, wpEndpoint, xmlResponse };

package/dist/index.js

@@ -34,8 +34,8 @@ import { TagCustomFieldsSchema } from "./tag/schema.js";
 import { CORE_PROCEDURES } from "./procedures.js";
 import { assertIntegrationEndpoints, assertIntegrationEnv, createIntegration, missingEndpoints, missingEnv, readEnv } from "./shared/integration.js";
 import { createEventHandler, createWebhookRouter } from "./webhook/index.js";
-import { Kizlo, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection } from "./kizlo.js";
+import { Kizlo, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection, wordPressConnectionComplete } from "./kizlo.js";
 import { SITEMAP_BASE, SITEMAP_INDEX_SLUG, createSitemapRedirectRoute, createSitemapRoute } from "./seo/sitemap.js";
 import { createMiddleware } from "./shared/middleware.js";
 
-export { COMMON_ERRORS, CONTENT_TYPES, CORE_PROCEDURES, CategoryCustomFieldsSchema, ContentType, Context, CookiesStorage, CurrencyFormat, IdentifierInput, Kizlo, KizloClient, KizloError, LIST_ORDER, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, PageCustomFieldsSchema, PostCustomFieldsSchema, PreviewTokenData, PreviewTokenPayload, Robots, RobotsRule, SITEMAP_BASE, SITEMAP_INDEX_SLUG, Seo, SeoHead, SeoSchema, SettingsService, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, TagCustomFieldsSchema, WEB_MANIFEST_ROUTE, WP_Error, WordPressTransport, altcha, arkose, assertIntegrationEndpoints, assertIntegrationEnv, authMock, buildProcedure, buildWebManifest, buildWordPressRequest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createGeoAdapter, createIntegration, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createResultClient, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, createWordPressClient, customFieldsSchema, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, integrationEnv, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, mergeServiceAdapters, missingEndpoints, missingEnv, noopAdapter, parseIdentifier, parseSitemapSlug, readEnv, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, resolveWordPressConnection, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, wpEndpoint, xmlResponse };
+export { COMMON_ERRORS, CONTENT_TYPES, CORE_PROCEDURES, CategoryCustomFieldsSchema, ContentType, Context, CookiesStorage, CurrencyFormat, IdentifierInput, Kizlo, KizloClient, KizloError, LIST_ORDER, ListMetadata, ListOrder, ListSitemapUrlInput, ListSitemapUrlInputBase, PageCustomFieldsSchema, PostCustomFieldsSchema, PreviewTokenData, PreviewTokenPayload, Robots, RobotsRule, SITEMAP_BASE, SITEMAP_INDEX_SLUG, Seo, SeoHead, SeoSchema, SettingsService, Sitemap, SitemapIndex, SitemapList, SitemapUrl, SitemapUrlImage, SitemapUrlList, TagCustomFieldsSchema, WEB_MANIFEST_ROUTE, WP_Error, WordPressTransport, altcha, arkose, assertIntegrationEndpoints, assertIntegrationEnv, authMock, buildProcedure, buildWebManifest, buildWordPressRequest, combineDetailed, compare, consoleLog, createAuthAdapter, createCaptchaAdapter, createCookiesAdapter, createEventHandler, createGeoAdapter, createIntegration, createKizlo, createKizloClient, createLoggerAdapter, createManifestRoute, createMiddleware, createOrpcRouter, createProcedure, createResultClient, createSitemapRedirectRoute, createSitemapRoute, createThrowableErrorMap, createWebhookRouter, createWordPressClient, customFieldsSchema, defineErrorMap, defineFixture, deserializeCurrencyFormat, deserializeListMetadata, deserializeSeo, emptyList, friendlyCaptcha, generateContract, geoMock, geoVercelNext, handleUnexpectedError, hash, hcaptcha, hmac, integrationEnv, isContractProcedure, isKizloError, isLocalPlugin, isWordPressResourceError, mergeServiceAdapters, missingEndpoints, missingEnv, noopAdapter, parseIdentifier, parseSitemapSlug, readEnv, recaptcha, renderJsonLd, renderSitemapIndex, renderUrlSet, resolveIcons, resolveKizloConfig, resolveWordPressConnection, restoreContract, schemaType, serializeCurrencyFormat, sitemapEntryPath, toKizloError, turnstile, wordPressConnectionComplete, wpEndpoint, xmlResponse };

package/dist/kizlo.d.ts

@@ -52,6 +52,12 @@ interface CreateKizloOptions<TIntegrations extends readonly AnyIntegration[] = [
  * Kizlo's active WordPress connection from the canonical `mode` value.
  */
 declare function integrationEnv(integrations: readonly AnyIntegration[]): EnvReader;
+/**
+ * Whether the active profile carries a full WordPress connection, without throwing. The dev/generate
+ * flow uses this to decide whether introspection can be fetched at all; {@link resolveWordPressConnection}
+ * throws for the request path that must have a connection.
+ */
+declare function wordPressConnectionComplete(env: EnvReader): boolean;
 declare function resolveWordPressConnection(env: EnvReader): {
   credentials: WordPressCredentials;
 };
@@ -65,4 +71,4 @@ declare function resolveKizloConfig<TIntegrations extends readonly AnyIntegratio
  */
 declare function createKizlo<TIntegrations extends readonly AnyIntegration[] = []>(options?: CreateKizloOptions<TIntegrations>): Kizlo<TIntegrations>;
 //#endregion
-export { AnyKizloConfig, CreateKizloOptions, Kizlo, KizloConfig, RootProcedures, S2SClient, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection };
+export { AnyKizloConfig, CreateKizloOptions, Kizlo, KizloConfig, RootProcedures, S2SClient, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection, wordPressConnectionComplete };

package/dist/kizlo.js

@@ -8,7 +8,7 @@ import { isTypescriptObject } from "./shared/utils.js";
 import { Context } from "./context.js";
 import { CORE_PROCEDURES } from "./procedures.js";
 import { isContractGeneration } from "./shared/contract-generation.js";
-import { assertIntegrationEndpoints, assertIntegrationEnv, readEnv } from "./shared/integration.js";
+import { assertIntegrationEndpoints, assertIntegrationEnv, missingEnv, readEnv } from "./shared/integration.js";
 import { createWebhookRouter } from "./webhook/index.js";
 import { tryCatch } from "@kizlo/shared";
 import { ORPCError, createRouterClient } from "@orpc/server";
@@ -161,6 +161,20 @@ function requireEnvValue(name, env) {
 	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.` });
 }
+/** The three connection values a WordPress request needs, scoped to the active profile by {@link integrationEnv}. */
+const WORDPRESS_CONNECTION_VALUES = [
+	"wordpressUrl",
+	"wordpressUsername",
+	"wordpressPassword"
+];
+/**
+* Whether the active profile carries a full WordPress connection, without throwing. The dev/generate
+* flow uses this to decide whether introspection can be fetched at all; {@link resolveWordPressConnection}
+* throws for the request path that must have a connection.
+*/
+function wordPressConnectionComplete(env) {
+	return missingEnv(env, WORDPRESS_CONNECTION_VALUES).length === 0;
+}
 function resolveWordPressConnection(env) {
 	return { credentials: {
 		url: requireEnvValue("wordpressUrl", env),
@@ -194,4 +208,4 @@ function createKizlo(options) {
 }
 
 //#endregion
-export { Kizlo, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection };
+export { Kizlo, createKizlo, integrationEnv, resolveKizloConfig, resolveWordPressConnection, wordPressConnectionComplete };

package/dist/package.js

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

package/dist/test.d.ts

@@ -1,5 +1,5 @@
 import { DevPluginSource, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, JsonValue, LocalPlugin, PluginSource, SeedContext, SettleContext, TestAdminUser, TestCredentials, TestUser, defineFixture, isLocalPlugin } from "./cli/wp/types.js";
-import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease } from "./cli/wp/constants.js";
+import { APACHE_LISTEN_CONF, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, UPLOADS_INI, githubRelease, kizloRelease } from "./cli/wp/constants.js";
 import { DockerStack, DockerStatus, RunResult, Stack, StackStatus, compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, dockerHint, dockerStatus, runningProjectContainers, stackStatus, stopProjectContainers, wpCli, wpEval } from "./cli/wp/docker.js";
 import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, isSeeded, recordedPort, resolvePluginSource, settleFixtures } from "./cli/wp/utils.js";
 import { TestAuthAdapterUser, toTestUser } from "./test/users.js";
@@ -8,4 +8,4 @@ import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
 import { menuFixture } from "./menu/fixture.js";
 import { postFixture } from "./post/fixture.js";
 import { coreFixtures } from "./test/fixtures.js";
-export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, DevPluginSource, DockerStack, DockerStatus, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, INTROSPECTION_META_REL, JsonValue, LOCAL_DIR_REL, LocalPlugin, OPCACHE_INI, PluginSource, REMAP_ENTRYPOINT, RunResult, SEED_MARKER_OPTION, SEED_VERSION, SeedContext, SettleContext, Stack, StackStatus, TEST_ADMIN, TEST_USER, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };
+export { APACHE_LISTEN_CONF, CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, DevPluginSource, DockerStack, DockerStatus, Fixture, FixtureCleanupFn, FixtureSeedFn, FixtureSettleFn, INTROSPECTION_META_REL, JsonValue, LOCAL_DIR_REL, LocalPlugin, OPCACHE_INI, PluginSource, REMAP_ENTRYPOINT, RunResult, SEED_MARKER_OPTION, SEED_VERSION, SeedContext, SettleContext, Stack, StackStatus, TEST_ADMIN, TEST_USER, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, UPLOADS_INI, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };

package/dist/test.js

@@ -1,5 +1,5 @@
 import { defineFixture, isLocalPlugin } from "./cli/wp/types.js";
-import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease } from "./cli/wp/constants.js";
+import { APACHE_LISTEN_CONF, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, UPLOADS_INI, githubRelease, kizloRelease } from "./cli/wp/constants.js";
 import { compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, dockerHint, dockerStatus, runningProjectContainers, stackStatus, stopProjectContainers, wpCli, wpEval } from "./cli/wp/docker.js";
 import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, isSeeded, recordedPort, resolvePluginSource, settleFixtures } from "./cli/wp/utils.js";
 import { testAuthAdapter } from "./test/auth.js";
@@ -9,4 +9,4 @@ import { postFixture } from "./post/fixture.js";
 import { coreFixtures } from "./test/fixtures.js";
 import { toTestUser } from "./test/users.js";
 
-export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };
+export { APACHE_LISTEN_CONF, CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, UPLOADS_INI, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, dockerHint, dockerStatus, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, runningProjectContainers, settleFixtures, stackStatus, stopProjectContainers, testAuthAdapter, toTestUser, wpCli, wpEval };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizlo",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "type": "module",
   "description": "A headless WordPress framework for TypeScript.",
   "keywords": [