kizlo 0.1.0

package/dist/cli/wp/setup.js

@@ -0,0 +1,39 @@
+import { WordPressService } from "../../wordpress/service.js";
+import { credentialsPath } from "./utils.js";
+import { bootstrapWp } from "./bootstrap.js";
+import { dirname } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+
+//#region src/cli/wp/setup.ts
+/**
+* Phase 2 — after bootstrap, build a `SeedContext` and run each `Fixture.seed`
+* over REST, collecting namespaced fixtures, then write the credentials artifact
+* at `<config-dir>/.kizlo/test-credentials.json`. Returns a teardown that runs
+* each fixture's `cleanup`.
+*/
+async function runSeeds(config) {
+	const boot = await bootstrapWp(config);
+	const ctx = {
+		service: new WordPressService({ credentials: {
+			url: boot.url,
+			username: boot.users.admin.username,
+			password: boot.users.admin.applicationPassword
+		} }),
+		userId: boot.users.user.id,
+		adminId: boot.users.admin.id
+	};
+	for (const fixture of config.fixtures ?? []) if (fixture.seed) boot.fixtures[fixture.name] = await fixture.seed(ctx);
+	const path$1 = credentialsPath();
+	mkdirSync(dirname(path$1), { recursive: true });
+	writeFileSync(path$1, `${JSON.stringify({
+		url: boot.url,
+		users: boot.users,
+		fixtures: boot.fixtures
+	}, null, 2)}\n`);
+	return async () => {
+		for (const fixture of config.fixtures ?? []) await fixture.cleanup?.(ctx);
+	};
+}
+
+//#endregion
+export { runSeeds };

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

@@ -0,0 +1,72 @@
+import { WordPressService } from "../../wordpress/service.js";
+import "../../wordpress/index.js";
+
+//#region src/cli/wp/types.d.ts
+interface BaseTestUser {
+  id: number;
+  email: string;
+  firstName: string;
+  lastName: string;
+  username: string;
+  password: string;
+}
+interface TestAdminUser extends BaseTestUser {
+  applicationPassword: string;
+}
+interface TestUser extends BaseTestUser {
+  role: "subscriber";
+}
+/** Any JSON-serializable value — the artifact is written via `JSON.stringify`. */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * Shape of the credentials artifact written by `runSeeds` and consumed by
+ * `getKizloTestInstance`. The contract between the CLI writer and the test reader
+ * is this JSON file — neither side imports the other at runtime.
+ */
+interface TestCredentials {
+  url: string;
+  users: {
+    user: TestUser;
+    admin: TestAdminUser;
+  };
+  /**
+   * Per-fixture handles, keyed by `Fixture.name`. By convention each fixture
+   * stores the ids (or codes/slugs) of what it created — handles to re-fetch the
+   * live resource — not full snapshots, which would drift from WP state.
+   */
+  fixtures: Record<string, Record<string, JsonValue>>;
+}
+/** Handed to each `Fixture` so it can create its world over REST (or wp-cli). */
+interface SeedContext {
+  service: WordPressService;
+  adminId: number;
+  userId: number;
+}
+/**
+ * A plugin to ensure installed + active during bootstrap. A bare string is a
+ * wp.org slug (the installed name and the install source are the same). The
+ * object form is for any other source — a zip URL or a local path — where the
+ * installed slug (`name`, used for activation checks) can't be derived from the
+ * source. `source` is passed straight to `wp plugin install`.
+ */
+type PluginSource = string | {
+  name: string;
+  source: string;
+};
+/** The serializable test layer an extension ships alongside its live extension. */
+interface Fixture {
+  /** Namespace key under `TestCredentials.fixtures`. */
+  name: string;
+  /** Plugins to install + activate via wp-cli during bootstrap, in order (deps first). */
+  plugins?: PluginSource[];
+  /** Build this extension's world once during seeding; return created handles. */
+  seed?: (ctx: SeedContext) => Promise<Record<string, JsonValue>>;
+  /** Revert per-test mutations (teardown); does NOT uninstall plugins or seeded data. */
+  cleanup?: (ctx: SeedContext) => Promise<void>;
+}
+/** Identity helper for authoring a `Fixture` with full inference and autocomplete. */
+declare function defineFixture(fixture: Fixture): Fixture;
+//#endregion
+export { Fixture, JsonValue, PluginSource, SeedContext, TestAdminUser, TestCredentials, TestUser, defineFixture };

package/dist/cli/wp/types.js

@@ -0,0 +1,8 @@
+//#region src/cli/wp/types.ts
+/** Identity helper for authoring a `Fixture` with full inference and autocomplete. */
+function defineFixture(fixture) {
+	return fixture;
+}
+
+//#endregion
+export { defineFixture };

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

@@ -0,0 +1,39 @@
+import { PluginSource, TestCredentials } from "./types.js";
+
+//#region src/cli/wp/utils.d.ts
+
+/**
+ * True only when the stack is already seeded: the credentials artifact exists on
+ * the host and this database carries the current seed marker (an option written
+ * as the final bootstrap step). The marker is independent of fixture content, so
+ * it stays accurate no matter which fixtures a consumer mounts; `option get` also
+ * fails when core isn't installed, so it doubles as the DB-initialized check.
+ *
+ * After `wp reset` the DB volume is gone so the marker is absent and `wp up`
+ * reseeds; after `wp stop` the DB is intact so it passes and `wp up` just resumes.
+ * Bumping `SEED_VERSION` invalidates older marks and forces a reseed.
+ */
+declare function isSeeded(): Promise<boolean>;
+/** Build a GitHub release-zip URL for `PluginSource.source` (asset named `<tag>.zip`). */
+declare function githubRelease(repo: string, tag: string): string;
+/** Resolve a `PluginSource` to the `(name, source)` pair `ensurePlugin` needs. */
+declare function resolvePluginSource(plugin: PluginSource): [name: string, source: string];
+/**
+ * Ensure a plugin is active without ever re-downloading. Plugin files persist in
+ * the `wp_data` volume, so an already-installed plugin is just activated; the
+ * download (`source` = release zip URL or wp.org slug) happens only when the files
+ * are absent (i.e. after `wp reset` wipes the volume).
+ */
+declare function ensurePlugin(name: string, source: string): Promise<void>;
+/**
+ * The directory holding `kizlo.config.*`, found by walking up from `cwd` (falling
+ * back to `cwd` when none is found). Anchoring the credentials artifact here —
+ * rather than each process's cwd — is what lets the CLI writer and the test reader
+ * agree even when tests run from a sub-directory of the config root.
+ */
+declare function findConfigDir(cwd?: string): string;
+/** Fixed credentials artifact path, anchored to the config root. */
+declare function credentialsPath(cwd?: string): string;
+declare function getTestCredentials(): TestCredentials;
+//#endregion
+export { credentialsPath, ensurePlugin, findConfigDir, getTestCredentials, githubRelease, isSeeded, resolvePluginSource };

package/dist/cli/wp/utils.js

@@ -0,0 +1,105 @@
+import { CONFIG_FILES, CREDENTIALS_REL, SEED_MARKER_OPTION, SEED_VERSION } from "./constants.js";
+import { compose, wpCli } from "./docker.js";
+import { dirname, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/cli/wp/utils.ts
+/**
+* True only when the stack is already seeded: the credentials artifact exists on
+* the host and this database carries the current seed marker (an option written
+* as the final bootstrap step). The marker is independent of fixture content, so
+* it stays accurate no matter which fixtures a consumer mounts; `option get` also
+* fails when core isn't installed, so it doubles as the DB-initialized check.
+*
+* After `wp reset` the DB volume is gone so the marker is absent and `wp up`
+* reseeds; after `wp stop` the DB is intact so it passes and `wp up` just resumes.
+* Bumping `SEED_VERSION` invalidates older marks and forces a reseed.
+*/
+async function isSeeded() {
+	if (!existsSync(credentialsPath())) return false;
+	const marker = await compose([
+		"exec",
+		"-T",
+		"wp-cli",
+		"wp",
+		"option",
+		"get",
+		SEED_MARKER_OPTION
+	]);
+	return marker.code === 0 && marker.stdout.trim() === SEED_VERSION;
+}
+/** Build a GitHub release-zip URL for `PluginSource.source` (asset named `<tag>.zip`). */
+function githubRelease(repo, tag) {
+	return `https://github.com/${repo}/releases/download/${tag}/${tag}.zip`;
+}
+/** Resolve a `PluginSource` to the `(name, source)` pair `ensurePlugin` needs. */
+function resolvePluginSource(plugin) {
+	return typeof plugin === "string" ? [plugin, plugin] : [plugin.name, plugin.source];
+}
+/**
+* Ensure a plugin is active without ever re-downloading. Plugin files persist in
+* the `wp_data` volume, so an already-installed plugin is just activated; the
+* download (`source` = release zip URL or wp.org slug) happens only when the files
+* are absent (i.e. after `wp reset` wipes the volume).
+*/
+async function ensurePlugin(name, source) {
+	if ((await compose([
+		"exec",
+		"-T",
+		"wp-cli",
+		"wp",
+		"plugin",
+		"is-active",
+		name
+	])).code === 0) return;
+	if ((await compose([
+		"exec",
+		"-T",
+		"wp-cli",
+		"wp",
+		"plugin",
+		"is-installed",
+		name
+	])).code === 0) {
+		await wpCli([
+			"plugin",
+			"activate",
+			name
+		]);
+		return;
+	}
+	await wpCli([
+		"plugin",
+		"install",
+		source,
+		"--activate"
+	]);
+}
+/**
+* The directory holding `kizlo.config.*`, found by walking up from `cwd` (falling
+* back to `cwd` when none is found). Anchoring the credentials artifact here —
+* rather than each process's cwd — is what lets the CLI writer and the test reader
+* agree even when tests run from a sub-directory of the config root.
+*/
+function findConfigDir(cwd = process.cwd()) {
+	let dir = resolve(cwd);
+	for (;;) {
+		if (CONFIG_FILES.some((name) => existsSync(resolve(dir, name)))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return resolve(cwd);
+		dir = parent;
+	}
+}
+/** Fixed credentials artifact path, anchored to the config root. */
+function credentialsPath(cwd) {
+	return resolve(findConfigDir(cwd), CREDENTIALS_REL);
+}
+let cached = null;
+function getTestCredentials() {
+	if (cached) return cached;
+	cached = JSON.parse(readFileSync(credentialsPath(), "utf-8"));
+	return cached;
+}
+
+//#endregion
+export { credentialsPath, ensurePlugin, findConfigDir, getTestCredentials, githubRelease, isSeeded, resolvePluginSource };

package/dist/client.d.ts

@@ -0,0 +1,24 @@
+import { ResultClient } from "./shared/result.js";
+import { AnyProcedureRouter, ExtractProcedureByScope } from "./shared/procedure.js";
+
+//#region src/client.d.ts
+interface KizloClientConfig<T extends AnyProcedureRouter> {
+  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>);
+  private getUrl;
+}
+/**
+ * Creates a browser client for a generated contract. Defaults the URL to the
+ * current origin; framework packages wrap this to resolve it from their env.
+ */
+declare function createKizloClient<T extends AnyProcedureRouter>(contract: T, options?: {
+  url?: string;
+}): KizloClient<T>;
+//#endregion
+export { KizloClient, KizloClientConfig, createKizloClient };

package/dist/client.js

@@ -0,0 +1,55 @@
+import { RPC_PROTOCOL_HEADER } from "./shared/constants.js";
+import { isContractProcedure as isContractProcedure$1, restoreContract } from "./shared/contract.js";
+import { createResultClient } from "./shared/result.js";
+import { getObjectProperty } from "./shared/utils.js";
+import { DynamicLink, createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { inferRPCMethodFromContractRouter } from "@orpc/contract";
+import { OpenAPILink } from "@orpc/openapi-client/fetch";
+
+//#region src/client.ts
+var KizloClient = class {
+	client;
+	config;
+	constructor(config) {
+		this.config = config;
+		const url = this.getUrl();
+		const orpcContract = restoreContract(config.contract);
+		const openapiLink = new OpenAPILink(orpcContract, {
+			url,
+			fetch: config.fetch
+		});
+		const remoteLink = new RPCLink({
+			url,
+			fetch: config.fetch,
+			headers: { [RPC_PROTOCOL_HEADER]: "1" },
+			method: inferRPCMethodFromContractRouter(orpcContract)
+		});
+		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.`);
+			switch (procedure.scope) {
+				case "internal": throw new Error("Internal procedure can only be called on the server.");
+				case "api": return openapiLink;
+				case "remote": return remoteLink;
+				default: throw new Error();
+			}
+		})));
+	}
+	getUrl() {
+		return this.config.url ?? window.location.href;
+	}
+};
+/**
+* Creates a browser client for a generated contract. Defaults the URL to the
+* current origin; framework packages wrap this to resolve it from their env.
+*/
+function createKizloClient(contract, options) {
+	return new KizloClient({
+		contract,
+		url: options?.url
+	});
+}
+
+//#endregion
+export { KizloClient, createKizloClient };

package/dist/comment/errors.js

@@ -0,0 +1,47 @@
+import { defineErrorMap } from "../shared/error.js";
+
+//#region src/comment/errors.ts
+const GET_COMMENT_ERROR_MAP = defineErrorMap({
+	COMMENT_NOT_FOUND: {
+		status: 404,
+		message: "Comment not found."
+	},
+	COMMENT_FORBIDDEN: {
+		status: 403,
+		message: "You are not allowed to read this comment."
+	}
+});
+const LIST_COMMENT_ERROR_MAP = defineErrorMap({
+	COMMENT_FORBIDDEN: {
+		status: 403,
+		message: "You are not allowed to read comments."
+	},
+	COMMENT_POST_TYPE_NOT_SUPPORTED: {
+		status: 400,
+		message: "The post type does not support comments."
+	}
+});
+const SUBMIT_COMMENT_ERROR_MAP = defineErrorMap({
+	COMMENT_USER_NOT_FOUND: {},
+	COMMENT_ID_NOT_FOUND: {},
+	COMMENT_CLOSED: {},
+	COMMENT_LOGIN_REQUIRED: {},
+	COMMENT_NAME_EMAIL_REQUIRED: {},
+	COMMENT_INVALID_EMAIL: {},
+	COMMENT_EMPTY_CONTENT: {},
+	COMMENT_FIELD_TOO_LONG: {},
+	COMMENT_DUPLICATE: {},
+	COMMENT_RATE_LIMITED: {},
+	COMMENT_PARENT_UNAPPROVED: {},
+	COMMENT_CAPTCHA_REQUIRED: {
+		status: 400,
+		message: "Comment captcha is required."
+	},
+	COMMENT_CAPTCHA_INVALID: {
+		status: 400,
+		message: "Comment captcha is invalid."
+	}
+});
+
+//#endregion
+export { GET_COMMENT_ERROR_MAP, LIST_COMMENT_ERROR_MAP, SUBMIT_COMMENT_ERROR_MAP };

package/dist/comment/index.js

@@ -0,0 +1,138 @@
+import { createProcedure } from "../shared/procedure.js";
+import { WP_CORE_BASE, WP_KIZLO_BASE } from "../wordpress/constants.js";
+import { deserializeListMetadata } from "../shared/serialize.js";
+import { GET_COMMENT_ERROR_MAP, LIST_COMMENT_ERROR_MAP, SUBMIT_COMMENT_ERROR_MAP } from "./errors.js";
+import { Comment, CommentList, GetCommentInput, ListCommentInput, SubmitCommentInput } from "./schema.js";
+import { deserializeComment } from "./utils.js";
+
+//#region src/comment/index.ts
+const COMMENT_ROUTER_MAP = {
+	get: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/comments/{id}",
+		params: GetCommentInput.pick({ id: true }),
+		query: GetCommentInput.pick({ password: true }).optional(),
+		errors: GET_COMMENT_ERROR_MAP,
+		output: Comment
+	}, async ({ context, errors, input }) => {
+		const response = await context.service.wordpress.get(`/comments/${input.params.id}`, {
+			base: WP_CORE_BASE,
+			searchParams: { password: input.query?.password }
+		});
+		if (response.error) switch (response.error.code) {
+			case "rest_comment_invalid_id":
+			case "rest_post_invalid_id": throw errors.COMMENT_NOT_FOUND();
+			case "rest_cannot_read":
+			case "rest_cannot_read_post": throw errors.COMMENT_FORBIDDEN();
+			default:
+				context.logger.error("Get comment unhandled error", response.error, {
+					commentId: input.params.id,
+					code: response.error.code
+				});
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeComment(response.data);
+	}),
+	list: createProcedure({
+		scope: "api",
+		method: "GET",
+		path: "/comments",
+		query: ListCommentInput.optional(),
+		errors: LIST_COMMENT_ERROR_MAP,
+		output: CommentList
+	}, async ({ context, errors, input }) => {
+		const response = await context.service.wordpress.get(`/comments`, {
+			base: WP_CORE_BASE,
+			searchParams: {
+				context: "edit",
+				after: input.query?.after,
+				author: input.query?.author,
+				author_exclude: input.query?.authorExclude,
+				before: input.query?.before,
+				exclude: input.query?.exclude,
+				include: input.query?.include,
+				offset: input.query?.offset,
+				order: input.query?.order,
+				orderby: input.query?.orderby,
+				page: input.query?.page,
+				parent: input.query?.parent,
+				parent_exclude: input.query?.parentExclude,
+				password: input.query?.password,
+				per_page: input.query?.perPage,
+				post: input.query?.post,
+				search: input.query?.search
+			}
+		});
+		if (response.error) switch (response.error.code) {
+			case "rest_cannot_read":
+			case "rest_cannot_read_post":
+			case "rest_forbidden_context":
+			case "rest_forbidden_param": throw errors.COMMENT_FORBIDDEN();
+			case "rest_comment_not_supported_post_type": throw errors.COMMENT_POST_TYPE_NOT_SUPPORTED();
+			default:
+				context.logger.error("List comments unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		const list = context.service.wordpress.resolveList({
+			data: response.data,
+			headers: response.headers,
+			searchParams: input.query
+		});
+		return {
+			items: list.items.map(deserializeComment),
+			meta: deserializeListMetadata(list.meta)
+		};
+	}),
+	submit: createProcedure({
+		scope: "api",
+		method: "POST",
+		path: "/comments",
+		body: SubmitCommentInput,
+		errors: SUBMIT_COMMENT_ERROR_MAP,
+		output: Comment
+	}, async ({ context, errors, input }) => {
+		const connInfo = await context.getConnInfo();
+		if (!connInfo?.ip) throw new Error("Connection IP is required.");
+		if (!connInfo?.userAgent) throw new Error("Connection user agent is required.");
+		const user = await context.getAuthUser();
+		if (!user) {
+			if (!input.body.captchaToken) throw errors.COMMENT_CAPTCHA_REQUIRED();
+			if (!await context.verifyCaptcha(input.body.captchaToken)) throw errors.COMMENT_CAPTCHA_INVALID();
+		}
+		const response = await context.service.wordpress.post(`/comments`, {
+			body: {
+				user_id: user?.id,
+				author_ip: connInfo.ip,
+				user_agent: connInfo.userAgent,
+				content: input.body.content,
+				post_id: input.body.postId,
+				author_email: input.body.authorEmail,
+				author_name: input.body.authorName,
+				author_url: input.body.authorUrl,
+				parent: input.body.parentId
+			},
+			base: WP_KIZLO_BASE
+		});
+		if (response.error) switch (response.error.code) {
+			case "rest_comment_author_data_required": throw errors.COMMENT_NAME_EMAIL_REQUIRED();
+			case "rest_comment_author_invalid":
+			case "rest_comment_invalid_author": throw errors.COMMENT_USER_NOT_FOUND();
+			case "rest_comment_content_invalid": throw errors.COMMENT_EMPTY_CONTENT();
+			case "rest_comment_login_required": throw errors.COMMENT_LOGIN_REQUIRED();
+			case "rest_comment_closed": throw errors.COMMENT_CLOSED();
+			case "rest_cannot_read_post":
+			case "rest_comment_draft_post":
+			case "rest_comment_invalid_post_id":
+			case "rest_comment_not_supported_post_type":
+			case "rest_comment_trash_post": throw errors.COMMENT_ID_NOT_FOUND();
+			default:
+				context.logger.error("Submit comment unhandled error", response.error, { code: response.error.code });
+				throw errors.INTERNAL_SERVER_ERROR();
+		}
+		return deserializeComment(response.data);
+	})
+};
+
+//#endregion
+export { COMMENT_ROUTER_MAP };

package/dist/comment/schema.js

@@ -0,0 +1,72 @@
+import { ListMetadata, ListOrder, Media } from "../shared/schema.js";
+import { NumberLike, arrayable } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/comment/schema.ts
+const CommentAuthorRef = z.object({
+	id: z.number(),
+	name: z.string(),
+	avatar: Media.nullable()
+});
+const CommentPostRef = z.object({
+	id: z.number(),
+	slug: z.string(),
+	title: z.string(),
+	image: Media.nullable()
+});
+const Comment = z.object({
+	id: z.number(),
+	parentId: z.number(),
+	author: CommentAuthorRef.nullable(),
+	content: z.string(),
+	post: CommentPostRef,
+	replyCount: z.number(),
+	postedAt: z.number(),
+	isApproved: z.boolean()
+});
+const GetCommentInput = z.object({
+	id: NumberLike,
+	password: z.string().optional()
+});
+const COMMENT_LIST_ORDER_BYS = [
+	"date",
+	"id",
+	"include",
+	"post",
+	"parent"
+];
+const CommentListOrderBy = z.enum(COMMENT_LIST_ORDER_BYS);
+const ListCommentInput = z.object({
+	page: NumberLike.optional(),
+	perPage: NumberLike.optional(),
+	search: z.string().optional(),
+	after: z.iso.datetime().optional(),
+	author: arrayable(NumberLike).optional(),
+	authorExclude: arrayable(NumberLike).optional(),
+	before: z.iso.datetime().optional(),
+	exclude: arrayable(NumberLike).optional(),
+	include: arrayable(NumberLike).optional(),
+	offset: NumberLike.optional(),
+	order: ListOrder.optional(),
+	orderby: CommentListOrderBy.optional(),
+	parent: arrayable(NumberLike).optional(),
+	parentExclude: arrayable(NumberLike).optional(),
+	post: arrayable(NumberLike).optional(),
+	password: z.string().optional()
+});
+const CommentList = z.object({
+	items: z.array(Comment),
+	meta: ListMetadata
+});
+const SubmitCommentInput = z.object({
+	postId: z.number(),
+	parentId: z.number().optional(),
+	content: z.string(),
+	authorEmail: z.email().optional(),
+	authorName: z.string().optional(),
+	authorUrl: z.url().optional(),
+	captchaToken: z.string().optional()
+});
+
+//#endregion
+export { Comment, CommentList, GetCommentInput, ListCommentInput, SubmitCommentInput };

package/dist/comment/utils.js

@@ -0,0 +1,35 @@
+//#region src/comment/utils.ts
+function deserializeComment(data) {
+	return {
+		id: data.id,
+		author: data.kizlo.author ? {
+			id: data.kizlo.author.id,
+			avatar: data.kizlo.author.avatar_url ? {
+				id: 0,
+				alt: "",
+				name: "",
+				src: data.kizlo.author.avatar_url
+			} : null,
+			name: data.kizlo.author.name
+		} : null,
+		content: data.content.rendered,
+		isApproved: data.status === "approved",
+		parentId: data.parent,
+		post: {
+			id: data.kizlo.post.id,
+			image: data.kizlo.post.featured_image ? {
+				id: data.kizlo.post.featured_image.id,
+				alt: data.kizlo.post.featured_image.alt,
+				src: data.kizlo.post.featured_image.url,
+				name: ""
+			} : null,
+			title: data.kizlo.post.title,
+			slug: data.kizlo.post.slug
+		},
+		postedAt: new Date(data.date).getTime(),
+		replyCount: data.kizlo.reply_count
+	};
+}
+
+//#endregion
+export { deserializeComment };

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+import { Fixture } from "./cli/wp/types.js";
+import "./test.js";
+
+//#region src/config.d.ts
+interface KizloTestConfig {
+  /** Published WP port (default 8080). */
+  port?: number;
+  /** Extension fixtures to install + seed. */
+  fixtures?: Fixture[];
+  /**
+   * Package manager used to launch the test script (default: auto-detected from
+   * the lockfile / package.json `packageManager`).
+   */
+  packageManager?: "npm" | "pnpm" | "yarn" | "bun";
+  /**
+   * Override the test command entirely. Default: `<packageManager> test` (the
+   * project's own `test` script — never hardcoded to vitest).
+   */
+  command?: string;
+}
+interface KizloGlobalConfig {
+  /**
+   * Kizlo's home directory. Kizlo owns the layout inside it: your server
+   * (`server/`, whose `index.ts` exports `router` plus your extensions), the
+   * browser `client.ts`, and the generated contract.
+   * @default 'src/lib/kizlo' (or 'lib/kizlo' without a src dir)
+   */
+  dir?: string;
+  /**
+   * Import alias prefix for generated imports (e.g. `@`). Detected from
+   * tsconfig at init; omit (or empty) to use relative imports.
+   */
+  alias?: string;
+  /** WordPress test environment used by `kizlo wp` and `kizlo test`. */
+  test?: KizloTestConfig;
+}
+declare function defineConfig(config: KizloGlobalConfig): KizloGlobalConfig;
+//#endregion
+export { KizloGlobalConfig, KizloTestConfig, defineConfig };