kizlo 0.6.1 → 0.8.0

package/dist/cli/presets/generated/templates.js

@@ -0,0 +1,59 @@
+//#region src/cli/presets/generated/templates.ts
+const TEMPLATE_SUBSETS = { "nextjs": [
+	{
+		"role": "server-entry",
+		"tokenizedPath": "{{kizloDir}}/server/index.ts",
+		"body": "import { createKizlo } from \"kizlo/nextjs/server\"\n\nexport const { router, client, context, handler } = createKizlo()\n"
+	},
+	{
+		"role": "client",
+		"tokenizedPath": "{{kizloDir}}/client.ts",
+		"body": "import { createKizloClient } from \"kizlo/nextjs\"\nimport { contract } from \"./server/generated\"\n\nexport const client = createKizloClient(contract)\n"
+	},
+	{
+		"role": "api-route",
+		"tokenizedPath": "{{appDir}}/api/kizlo/[[...rest]]/route.ts",
+		"body": "import { handler } from \"{{serverImport}}\"\n\nexport { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE, handler as OPTIONS }\n"
+	},
+	{
+		"role": "robots",
+		"tokenizedPath": "{{appDir}}/robots.txt/route.ts",
+		"body": "import { createRobotsRoute } from \"kizlo/nextjs/server\"\nimport { client } from \"{{serverImport}}\"\n\n// Run on the edge: cheaper and faster than Node for a response this small.\nexport const runtime = \"edge\"\n\n// Vercel treats special metadata files like robots.txt and sitemap.xml as completely static\n// files at build time, bypassing normal Incremental Static Regeneration (ISR) and on-demand\n// revalidatePath rules.\n//\n// While your revalidation logic executes perfectly in a local Node.js server, Vercel uploads\n// these routes directly to its Edge CDN as immutable assets. Subsequent on-demand revalidation\n// triggers will successfully clear the Data Cache but fail to purge the CDN-level Edge cache\n// for that file.\n//\n// force-dynamic opts out of that static treatment so CMS edits show up; the WordPress call is\n// cached, so requests stay cheap.\nexport const dynamic = \"force-dynamic\"\n\nexport const GET = createRobotsRoute(client)\n"
+	},
+	{
+		"role": "sitemap",
+		"tokenizedPath": "{{appDir}}/sitemaps/[sitemap]/route.ts",
+		"body": "import { createSitemapRoute } from \"kizlo/nextjs/server\"\nimport { client } from \"{{serverImport}}\"\n\n// Run on the edge: cheaper and faster than Node for a response this small.\nexport const runtime = \"edge\"\n\n// Like robots.txt, Vercel bakes sitemap routes into immutable Edge CDN assets at build time,\n// bypassing ISR and on-demand revalidatePath. The index gets frozen with whatever WordPress\n// returned at build (often nothing, since the self-referential backend isn't reachable yet),\n// and revalidation can't purge that CDN copy.\n//\n// force-dynamic opts out of that static treatment. createSitemapRoute caches the WordPress calls\n// per sitemap and refreshes them on content changes (via revalidateTag), so requests stay cheap.\nexport const dynamic = \"force-dynamic\"\n\nexport const GET = createSitemapRoute(client)\n"
+	},
+	{
+		"role": "sitemap-redirect",
+		"tokenizedPath": "{{appDir}}/sitemap.xml/route.ts",
+		"body": "import { createSitemapRedirectRoute } from \"kizlo/nextjs/server\"\n\n// Many crawlers ignore robots.txt and probe the well-known /sitemap.xml directly. This route\n// permanently redirects (308) to the generated index at /sitemaps/index.xml. The response is a\n// fixed constant with no WordPress call or request input, so Next statically generates it at\n// build time (no runtime/edge function invoked per request).\nexport const GET = createSitemapRedirectRoute()\n"
+	},
+	{
+		"role": "manifest",
+		"tokenizedPath": "{{appDir}}/site.webmanifest/route.ts",
+		"body": "import { createManifestRoute } from \"kizlo/nextjs/server\"\nimport { client } from \"{{serverImport}}\"\n\n// Run on the edge: cheaper and faster than Node for a response this small.\nexport const runtime = \"edge\"\n\n// Like robots.txt, Vercel bakes this route into an immutable Edge CDN asset at build time,\n// bypassing ISR and on-demand revalidatePath. force-dynamic opts out of that static treatment\n// so brand-settings edits show up; createManifestRoute caches the WordPress call, so requests\n// stay cheap.\nexport const dynamic = \"force-dynamic\"\n\nexport const GET = createManifestRoute(client)\n"
+	}
+] };
+const TEMPLATE_PATCHES = { "nextjs": [{
+	"label": "root layout",
+	"tokenizedFile": "{{appDir}}/layout.tsx",
+	"imports": [{
+		"module": "kizlo/nextjs/server",
+		"names": ["createRootMetadata", "createRootViewport"]
+	}, {
+		"module": "{{serverImport}}",
+		"names": ["client"]
+	}],
+	"exports": [{
+		"name": "generateMetadata",
+		"value": "createRootMetadata(client)"
+	}, {
+		"name": "generateViewport",
+		"value": "createRootViewport(client)"
+	}]
+}] };
+
+//#endregion
+export { TEMPLATE_PATCHES, TEMPLATE_SUBSETS };

package/dist/cli/presets/nextjs.js

@@ -1,3 +1,5 @@
+import { materializeTemplate } from "./template.js";
+
 //#region src/cli/presets/nextjs.ts
 const nextjs = {
 	id: "nextjs",
@@ -11,101 +13,7 @@ const nextjs = {
 	baseUrlEnvKey: "NEXT_PUBLIC_KIZLO_BACKEND_URL",
 	apiPath: "/api/kizlo",
 	scaffolds(ctx) {
-		const apiDir = `${ctx.appDir}/api/kizlo/[[...rest]]`;
-		const robotsDir = `${ctx.appDir}/robots.txt`;
-		const sitemapDir = `${ctx.appDir}/sitemaps/[sitemap]`;
-		const manifestDir = `${ctx.appDir}/site.webmanifest`;
-		return [
-			{
-				label: "Kizlo server instance",
-				relPath: ctx.serverEntryPath,
-				contents: `import { createKizlo } from "kizlo/nextjs/server"
-
-export const { router, client, context, handler } = createKizlo()
-`
-			},
-			{
-				label: "Browser client",
-				relPath: ctx.clientPath,
-				contents: `import { createKizloClient } from "kizlo/nextjs"
-import { contract } from "./${ctx.serverDirName}/generated"
-
-export const client = createKizloClient(contract)
-`
-			},
-			{
-				label: "API route",
-				relPath: `${apiDir}/route.ts`,
-				contents: `import { handler } from "${ctx.serverImport(apiDir)}"
-
-export { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE, handler as OPTIONS }
-`
-			},
-			{
-				label: "robots.txt route",
-				relPath: `${robotsDir}/route.ts`,
-				contents: `import { createRobotsRoute } from "kizlo/nextjs/server"
-import { client } from "${ctx.serverImport(robotsDir)}"
-
-// Run on the edge: cheaper and faster than Node for a response this small.
-export const runtime = "edge"
-
-// Vercel treats special metadata files like robots.txt and sitemap.xml as completely static
-// files at build time, bypassing normal Incremental Static Regeneration (ISR) and on-demand
-// revalidatePath rules.
-//
-// While your revalidation logic executes perfectly in a local Node.js server, Vercel uploads
-// these routes directly to its Edge CDN as immutable assets. Subsequent on-demand revalidation
-// triggers will successfully clear the Data Cache but fail to purge the CDN-level Edge cache
-// for that file.
-//
-// force-dynamic opts out of that static treatment so CMS edits show up; the WordPress call is
-// cached, so requests stay cheap.
-export const dynamic = "force-dynamic"
-
-export const GET = createRobotsRoute(client)
-`
-			},
-			{
-				label: "sitemap route",
-				relPath: `${sitemapDir}/route.ts`,
-				contents: `import { createSitemapRoute } from "kizlo/nextjs/server"
-import { client } from "${ctx.serverImport(sitemapDir)}"
-
-// Run on the edge: cheaper and faster than Node for a response this small.
-export const runtime = "edge"
-
-// Like robots.txt, Vercel bakes sitemap routes into immutable Edge CDN assets at build time,
-// bypassing ISR and on-demand revalidatePath. The index gets frozen with whatever WordPress
-// returned at build (often nothing, since the self-referential backend isn't reachable yet),
-// and revalidation can't purge that CDN copy.
-//
-// force-dynamic opts out of that static treatment. createSitemapRoute caches the WordPress calls
-// per sitemap and refreshes them on content changes (via revalidateTag), so requests stay cheap.
-export const dynamic = "force-dynamic"
-
-export const GET = createSitemapRoute(client)
-`
-			},
-			{
-				label: "web manifest route",
-				relPath: `${manifestDir}/route.ts`,
-				contents: `import { createManifestRoute } from "kizlo/nextjs/server"
-import { client } from "${ctx.serverImport(manifestDir)}"
-
-// Run on the edge: cheaper and faster than Node for a response this small.
-export const runtime = "edge"
-
-// Like robots.txt, Vercel bakes this route into an immutable Edge CDN asset at build time,
-// bypassing ISR and on-demand revalidatePath. force-dynamic opts out of that static treatment
-// so brand-settings edits show up; createManifestRoute caches the WordPress call, so requests
-// stay cheap.
-export const dynamic = "force-dynamic"
-
-export const GET = createManifestRoute(client)
-`
-			}
-		];
+		return materializeTemplate("nextjs", ctx);
 	}
 };
 

package/dist/cli/presets/patch.js

@@ -0,0 +1,133 @@
+import { TEMPLATE_PATCHES } from "./generated/templates.js";
+import path from "node:path";
+import fs from "node:fs";
+import { builders, detectCodeFormat, generateCode, parseModule } from "magicast";
+
+//#region src/cli/presets/patch.ts
+/** Extensions a patch target might really use, in preference order. The template names files `.tsx`,
+* but a JS project's layout may be `.js`/`.jsx`, so init probes these to find the actual file. */
+const PATCH_TARGET_EXTS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js",
+	".mjs",
+	".cjs"
+];
+/**
+* Resolve a patch's tokenized target to the real file on disk, trying the common component
+* extensions so a JS project's `layout.js`/`layout.jsx` is found — not just the template's `.tsx`.
+* Returns undefined when no candidate exists.
+*/
+function resolvePatchTargetPath(cwd, relPath) {
+	const direct = path.join(cwd, relPath);
+	if (fs.existsSync(direct)) return direct;
+	const base = relPath.replace(/\.[^./]+$/, "");
+	for (const ext of PATCH_TARGET_EXTS) {
+		const candidate = path.join(cwd, `${base}${ext}`);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+}
+/** The Kizlo-wiring patches for a framework (files init merges into rather than writes). */
+function templatePatches(framework) {
+	return TEMPLATE_PATCHES[framework] ?? [];
+}
+/** Substitute the path/import tokens for a patch against the project's real directories. */
+function resolvePatch(patch, ctx) {
+	const relPath = patch.tokenizedFile.replaceAll("{{kizloDir}}", ctx.kizloDir).replaceAll("{{appDir}}", ctx.appDir);
+	const fromDir = path.posix.dirname(relPath);
+	const imports = patch.imports.map((imp) => ({
+		module: imp.module.replaceAll("{{serverImport}}", ctx.serverImport(fromDir)),
+		names: imp.names
+	}));
+	return {
+		label: patch.label,
+		relPath,
+		imports,
+		exports: patch.exports
+	};
+}
+/** Whether a patch actually modified the file (vs. a no-op / kept outcome). */
+function patchChanged(changes) {
+	return Boolean(changes.addedImports.length || changes.addedExports.length || changes.replacedExports.length);
+}
+/**
+* Next.js pairs a dynamic `generateX` export with a static `x` export (e.g. `generateMetadata` and
+* `metadata`) and rejects a file that declares both. When we add a `generateX`, its static
+* counterpart is a conflict too — return `metadata` for `generateMetadata`, `viewport` for
+* `generateViewport`, and so on; undefined for anything that isn't a `generate*` name.
+*/
+function staticCounterpart(name) {
+	const match = /^generate([A-Z]\w*)$/.exec(name);
+	if (!match) return void 0;
+	const rest = match[1] ?? "";
+	return rest.charAt(0).toLowerCase() + rest.slice(1);
+}
+/** Whitespace-insensitive equality, for telling "already our wiring" apart from a user's own export. */
+function sameExpr(a, b) {
+	return a.replace(/\s+/g, "") === b.replace(/\s+/g, "");
+}
+/**
+* Merge a resolved patch into `source` by parsing it with magicast (a real TS/JS/JSX parser via Babel,
+* so declarations are bounded exactly — never by a text heuristic). Imports and absent exports are
+* added; an export the file already defines is replaced surgically when `replaceConflicts` is set, else
+* kept. A static Next counterpart (`metadata` for `generateMetadata`) is dropped as part of a replace.
+* Idempotent: an export whose current value already equals ours is left untouched.
+*
+* Throws if the target cannot be parsed or regenerated. Callers must NOT swallow that — a file we can't
+* parse is one we must not guess at, so wiring stops rather than writing a corrupted file.
+*/
+function applyPatchToSource(source, patch, opts) {
+	const format = detectCodeFormat(source);
+	const mod = parseModule(source, {
+		sourceFileName: "layout.tsx",
+		...format
+	});
+	const changes = {
+		addedImports: [],
+		addedExports: [],
+		replacedExports: [],
+		keptExports: []
+	};
+	for (const imp of patch.imports) for (const name of imp.names) {
+		if (mod.imports.$items.some((item) => item.from === imp.module && item.imported === name)) continue;
+		mod.imports.$append({
+			imported: name,
+			from: imp.module
+		});
+		changes.addedImports.push(name);
+	}
+	for (const exp of patch.exports) {
+		const exportNames = Object.keys(mod.exports);
+		if (exportNames.includes(exp.name)) {
+			if (sameExpr(generateCode(mod.exports[exp.name]).code, exp.value)) continue;
+			if (!opts.replaceConflicts) {
+				changes.keptExports.push(exp.name);
+				continue;
+			}
+			mod.exports[exp.name] = builders.raw(exp.value);
+			changes.replacedExports.push(exp.name);
+			continue;
+		}
+		const counterpart = staticCounterpart(exp.name);
+		if (counterpart && exportNames.includes(counterpart)) {
+			if (!opts.replaceConflicts) {
+				changes.keptExports.push(exp.name);
+				continue;
+			}
+			delete mod.exports[counterpart];
+			mod.exports[exp.name] = builders.raw(exp.value);
+			changes.replacedExports.push(exp.name);
+			continue;
+		}
+		mod.exports[exp.name] = builders.raw(exp.value);
+		changes.addedExports.push(exp.name);
+	}
+	return {
+		text: generateCode(mod, { format }).code,
+		changes
+	};
+}
+
+//#endregion
+export { applyPatchToSource, patchChanged, resolvePatch, resolvePatchTargetPath, templatePatches };

package/dist/cli/presets/template.js

@@ -0,0 +1,36 @@
+import { TEMPLATE_SUBSETS } from "./generated/templates.js";
+import path from "node:path";
+
+//#region src/cli/presets/template.ts
+/** Role → the human label init uses in prompts and logs. Mirrors the old hardcoded labels. */
+const ROLE_LABELS = {
+	"server-entry": "Kizlo server instance",
+	client: "Browser client",
+	"api-route": "API route",
+	robots: "robots.txt route",
+	sitemap: "sitemap route",
+	"sitemap-redirect": "sitemap.xml redirect route",
+	manifest: "web manifest route"
+};
+/**
+* Turn a framework's extracted template subset into the {@link ScaffoldFile}s init writes, by
+* substituting the tokens the extractor left behind: the path prefixes (`{{kizloDir}}`, `{{appDir}}`)
+* with the project's real directories, and `{{serverImport}}` with the import specifier resolved for
+* each file's location (tsconfig alias or relative). The single source of these bodies is the
+* template folder, so init and `create` can never drift.
+*/
+function materializeTemplate(framework, ctx) {
+	return (TEMPLATE_SUBSETS[framework] ?? []).map((file) => {
+		const relPath = file.tokenizedPath.replaceAll("{{kizloDir}}", ctx.kizloDir).replaceAll("{{appDir}}", ctx.appDir);
+		const fromDir = path.posix.dirname(relPath);
+		const contents = file.body.replaceAll("{{serverImport}}", ctx.serverImport(fromDir));
+		return {
+			label: ROLE_LABELS[file.role] ?? file.role,
+			relPath,
+			contents
+		};
+	});
+}
+
+//#endregion
+export { materializeTemplate };

package/dist/cli/wp/dev.js

@@ -7,12 +7,27 @@ import { prepareByo } from "./byo.js";
 import { join } from "node:path";
 import { existsSync, rmSync } from "node:fs";
 import { randomBytes } from "node:crypto";
+import { networkInterfaces } from "node:os";
 
 //#region src/cli/wp/dev.ts
 /** A strong random admin password (144 bits, URL/JSON/CLI-safe characters). */
 function generatePassword() {
 	return randomBytes(18).toString("base64url");
 }
+/** First non-internal IPv4 address — the router-assigned LAN address (undefined when offline). */
+function lanAddress() {
+	for (const ifaces of Object.values(networkInterfaces())) for (const iface of ifaces ?? []) if (iface.family === "IPv4" && !iface.internal) return iface.address;
+}
+/**
+* The URL the dev stack is provisioned at. We prefer the router-assigned LAN address over `localhost`
+* so it's reachable from off the host (the app in a container or on another device). Serving WordPress
+* under the request host is already handled by the container's `WORDPRESS_CONFIG_EXTRA` (it derives
+* `WP_HOME`/`WP_SITEURL` from `HTTP_HOST` per request), so this is only the address we write into `.env`
+* and print. Falls back to `localhost` when the machine is offline, so bare local dev still works.
+*/
+function devUrl(port) {
+	return `http://${lanAddress() ?? "localhost"}:${port}`;
+}
 /**
 * Seed `dev.fixtures` into a freshly installed dev stack, reusing the test seeding
 * primitives: seed the default subscriber so `ctx.userId` exists, then run each `seed`
@@ -58,7 +73,7 @@ async function seedDevFixtures(cfg, url) {
 * concern.
 */
 async function bootstrapDev(cfg) {
-	const url = `http://localhost:${cfg.port}`;
+	const url = devUrl(cfg.port);
 	const byo = !existsSync(join(cfg.wordpressDir, "wp-includes", "version.php")) && cfg.byo ? await prepareByo(cfg.byo, cfg.wordpressDir, cfg.configDir) : void 0;
 	await composeUp();
 	const installed = (await compose([

package/dist/comment/index.js

@@ -16,7 +16,7 @@ const COMMENT_ROUTER_MAP = {
 		errors: GET_COMMENT_ERROR_MAP,
 		output: Comment
 	}, async ({ context, errors, input }) => {
-		const response = await context.service.wordpress.get(`/comments/${input.params.id}`, {
+		const response = await context.wordpress.get(`/comments/${input.params.id}`, {
 			base: WP_CORE_BASE,
 			searchParams: { password: input.query?.password }
 		});
@@ -42,7 +42,7 @@ const COMMENT_ROUTER_MAP = {
 		errors: LIST_COMMENT_ERROR_MAP,
 		output: CommentList
 	}, async ({ context, errors, input }) => {
-		const response = await context.service.wordpress.get(`/comments`, {
+		const response = await context.wordpress.get(`/comments`, {
 			base: WP_CORE_BASE,
 			searchParams: {
 				context: "edit",
@@ -74,7 +74,7 @@ const COMMENT_ROUTER_MAP = {
 				context.logger.error("List comments unhandled error", response.error, { code: response.error.code });
 				throw errors.INTERNAL_SERVER_ERROR();
 		}
-		const list = context.service.wordpress.resolveList({
+		const list = context.wordpress.resolveList({
 			data: response.data,
 			headers: response.headers,
 			searchParams: input.query
@@ -100,7 +100,7 @@ const COMMENT_ROUTER_MAP = {
 			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`, {
+		const response = await context.wordpress.post(`/comments`, {
 			body: {
 				user_id: user?.id,
 				author_ip: connInfo.ip,

package/dist/context.d.ts

@@ -1,11 +1,13 @@
 import { WordPressCredentials } from "./wordpress/types.js";
+import { WordPressService } from "./wordpress/service.js";
 import "./wordpress/index.js";
 import { AuthUser } from "./adapters/auth.js";
 import { PreviewTokenPayload } from "./shared/schema.js";
 import { ConnInfo } from "./adapters/geo.js";
 import { Logger } from "./adapters/logger.js";
 import { CookiesStorage } from "./cookie.js";
-import { Service } from "./service.js";
+import { EmailService } from "./email/service.js";
+import { SettingsService } from "./settings/service.js";
 import { ServiceAdapters } from "./kizlo.js";
 
 //#region src/context.d.ts
@@ -18,15 +20,24 @@ type AuthUserFn = () => Promise<AuthUser | null>;
 type ConnInfoFn = () => Promise<ConnInfo | null>;
 type VerifyCaptchaFn = (token: string) => Promise<boolean>;
 type VerifyPreviewTokenFn = (token: string) => Promise<PreviewTokenPayload | null>;
-interface ServerContext {
+/**
+ * The context every procedure, middleware, event, and webhook handler receives — the fixed base
+ * the server builds. A procedure's handler receives this base plus whatever its middleware injected
+ * via `next({ context })`.
+ */
+interface ProcedureContext {
   /** The incoming HTTP `Request`, or `null` for server-side (non-HTTP) invocations. */
   request: Request | null;
   /** Response headers to be sent (e.g. `Set-Cookie`), or `null` server-side. */
   headers: Headers | null;
   /** The configured logger adapter. */
   logger: Logger;
-  /** Typed service clients — the WordPress client at `service.wordpress`, with more services added over time. */
-  service: Service;
+  /** Typed WordPress REST client. */
+  wordpress: WordPressService;
+  /** Kizlo settings client. */
+  settings: SettingsService;
+  /** Transactional email client. */
+  email: EmailService;
   /** The resolved context config: site secret, adapters, and WordPress credentials. */
   config: ContextConfig;
   /** Resolve the caller's connection info (IP, geo) via the geo adapter, or `null`. */
@@ -45,14 +56,18 @@ interface ServerContext {
 declare class Context {
   private readonly config;
   private readonly logger;
-  private readonly service;
+  private readonly wordpress;
+  private readonly settings;
+  private readonly email;
   constructor(config: ContextConfig);
   createRestContext(request: Request): {
     headers: Headers;
     request: Request;
     config: ContextConfig;
     logger: Logger;
-    service: Service;
+    wordpress: WordPressService;
+    settings: SettingsService;
+    email: EmailService;
     getConnInfo: ConnInfoFn;
     verifyCaptcha: VerifyCaptchaFn;
     getAuthUser: AuthUserFn;
@@ -66,7 +81,9 @@ declare class Context {
     request: null;
     config: ContextConfig;
     logger: Logger;
-    service: Service;
+    wordpress: WordPressService;
+    settings: SettingsService;
+    email: EmailService;
     getAuthUser: AuthUserFn;
     getConnInfo: ConnInfoFn;
     verifyCaptcha: VerifyCaptchaFn;
@@ -81,4 +98,4 @@ declare class Context {
   private createLogger;
 }
 //#endregion
-export { AuthUserFn, ConnInfoFn, Context, ContextConfig, ServerContext, VerifyCaptchaFn, VerifyPreviewTokenFn };
+export { AuthUserFn, ConnInfoFn, Context, ContextConfig, ProcedureContext, VerifyCaptchaFn, VerifyPreviewTokenFn };

package/dist/context.js

@@ -2,7 +2,9 @@ import { compare, hmac } from "./shared/crypto.js";
 import { noopAdapter } from "./adapters/logger.js";
 import { PreviewTokenData } from "./shared/schema.js";
 import { CookiesStorage } from "./cookie.js";
-import { Service } from "./service.js";
+import { WordPressService } from "./wordpress/service.js";
+import { EmailService } from "./email/service.js";
+import { SettingsService } from "./settings/service.js";
 import { base64Decode, tryCatchSync } from "@kizlo/shared";
 import { serialize } from "cookie";
 
@@ -10,10 +12,14 @@ import { serialize } from "cookie";
 var Context = class {
 	config;
 	logger;
-	service;
+	wordpress;
+	settings;
+	email;
 	constructor(config) {
 		this.config = config;
-		this.service = new Service(config);
+		this.wordpress = new WordPressService(config);
+		this.settings = new SettingsService(this.wordpress);
+		this.email = new EmailService(this.wordpress);
 		this.logger = this.createLogger();
 	}
 	createRestContext(request) {
@@ -23,7 +29,9 @@ var Context = class {
 			request: request.clone(),
 			config: this.config,
 			logger: this.logger,
-			service: this.service,
+			wordpress: this.wordpress,
+			settings: this.settings,
+			email: this.email,
 			getConnInfo: this.createConnInfoFn(request),
 			verifyCaptcha: this.createVerifyCaptchaFn(request),
 			getAuthUser: this.createGetUserFn(request),
@@ -39,7 +47,9 @@ var Context = class {
 			request: null,
 			config: this.config,
 			logger: this.logger,
-			service: this.service,
+			wordpress: this.wordpress,
+			settings: this.settings,
+			email: this.email,
 			getAuthUser: this.createGetUserFn(null),
 			getConnInfo: this.createConnInfoFn(null),
 			verifyCaptcha: this.createVerifyCaptchaFn(null),

package/dist/email/service.d.ts

@@ -1,10 +1,11 @@
+import { WordPressService } from "../wordpress/service.js";
+import "../wordpress/index.js";
 import { EmailSendParams } from "./service.interface.js";
-import { Service } from "../service.js";
 
 //#region src/email/service.d.ts
 declare class EmailService {
-  private readonly service;
-  constructor(service: Service);
+  private readonly wordpress;
+  constructor(wordpress: WordPressService);
   send(params: EmailSendParams): Promise<void>;
 }
 //#endregion

package/dist/email/service.js

@@ -2,12 +2,12 @@ import { WP_KIZLO_BASE } from "../wordpress/constants.js";
 
 //#region src/email/service.ts
 var EmailService = class {
-	service;
-	constructor(service) {
-		this.service = service;
+	wordpress;
+	constructor(wordpress) {
+		this.wordpress = wordpress;
 	}
 	async send(params) {
-		const { data, error } = await this.service.wordpress.post("/email/send", {
+		const { data, error } = await this.wordpress.post("/email/send", {
 			body: params,
 			base: WP_KIZLO_BASE
 		});