@geekmidas/cli 1.10.36 → 1.10.38

package/src/deploy/domain.ts

@@ -1,3 +1,4 @@
+import { getPublicEnvPrefix } from '../workspace/index.js';
 import type {
 	DokployWorkspaceConfig,
 	NormalizedAppConfig,
@@ -71,7 +72,7 @@ export function isMainFrontendApp(
 	app: NormalizedAppConfig,
 	allApps: Record<string, NormalizedAppConfig>,
 ): boolean {
-	if (app.type !== 'frontend') {
+	if (app.type !== 'web') {
 		return false;
 	}
 
@@ -82,7 +83,7 @@ export function isMainFrontendApp(
 
 	// Otherwise, check if this is the first frontend
 	for (const [name, a] of Object.entries(allApps)) {
-		if (a.type === 'frontend') {
+		if (a.type === 'web') {
 			return name === appName;
 		}
 	}
@@ -91,9 +92,13 @@ export function isMainFrontendApp(
 }
 
 /**
- * Generate public URL build args for a frontend app based on its dependencies.
+ * Generate public URL build args for a web/mobile app based on its dependencies.
  *
- * @param app - The frontend app configuration
+ * The prefix is chosen by the app's framework (NEXT_PUBLIC_, VITE_,
+ * EXPO_PUBLIC_, or none for Remix). Apps without a public prefix get no
+ * build args — they should fetch URLs at runtime instead.
+ *
+ * @param app - The web/mobile app configuration
  * @param deployedUrls - Map of app name to deployed public URL
  * @returns Array of build args like 'NEXT_PUBLIC_API_URL=https://api.example.com'
  */
@@ -101,14 +106,14 @@ export function generatePublicUrlBuildArgs(
 	app: NormalizedAppConfig,
 	deployedUrls: Record<string, string>,
 ): string[] {
-	const buildArgs: string[] = [];
+	const prefix = getPublicEnvPrefix(app);
+	if (!prefix) return [];
 
+	const buildArgs: string[] = [];
 	for (const dep of app.dependencies) {
 		const publicUrl = deployedUrls[dep];
 		if (publicUrl) {
-			// Convert app name to UPPER_SNAKE_CASE for env var
-			const envVarName = `NEXT_PUBLIC_${dep.toUpperCase()}_URL`;
-			buildArgs.push(`${envVarName}=${publicUrl}`);
+			buildArgs.push(`${prefix}${dep.toUpperCase()}_URL=${publicUrl}`);
 		}
 	}
 
@@ -118,9 +123,12 @@ export function generatePublicUrlBuildArgs(
 /**
  * Get public URL arg names from app dependencies.
  *
- * @param app - The frontend app configuration
- * @returns Array of arg names like 'NEXT_PUBLIC_API_URL'
+ * @param app - The web/mobile app configuration
+ * @returns Array of arg names like 'NEXT_PUBLIC_API_URL', or [] for frameworks
+ *   without a public prefix (e.g. Remix).
  */
 export function getPublicUrlArgNames(app: NormalizedAppConfig): string[] {
-	return app.dependencies.map((dep) => `NEXT_PUBLIC_${dep.toUpperCase()}_URL`);
+	const prefix = getPublicEnvPrefix(app);
+	if (!prefix) return [];
+	return app.dependencies.map((dep) => `${prefix}${dep.toUpperCase()}_URL`);
 }

package/src/deploy/index.ts

@@ -1202,11 +1202,22 @@ export async function workspaceDeployCommand(
 	// ==================================================================
 	// Separate apps by type for two-phase deployment
 	// ==================================================================
+	// Mobile apps deploy via their own toolchain (e.g. EAS Build for Expo)
+	// — skip them in the Dokploy deploy phases.
+	const skippedMobileApps = appsToDeployNames.filter(
+		(name) => workspace.apps[name]!.type === 'mobile',
+	);
+	if (skippedMobileApps.length > 0) {
+		logger.log(
+			`\n📱 Skipping ${skippedMobileApps.length} mobile app(s) — deploy via framework toolchain: ${skippedMobileApps.join(', ')}`,
+		);
+	}
+
 	const backendApps = appsToDeployNames.filter(
 		(name) => workspace.apps[name]!.type === 'backend',
 	);
 	const frontendApps = appsToDeployNames.filter(
-		(name) => workspace.apps[name]!.type === 'frontend',
+		(name) => workspace.apps[name]!.type === 'web',
 	);
 
 	// ==================================================================

package/src/deploy/sniffer.ts

@@ -117,7 +117,7 @@ export async function sniffAppEnvironment(
 	const { logWarnings = true, markOptional = false } = options;
 
 	// 1. Frontend apps - handle dependencies and config sniffing
-	if (app.type === 'frontend') {
+	if (app.type === 'web' || app.type === 'mobile') {
 		// Auto-generate {prefix}{DEP}_URL from dependencies, where prefix matches
 		// the framework's public-var convention (NEXT_PUBLIC_, VITE_, ...).
 		// For frameworks without a prefix (e.g. Remix), no dep var is required.

package/src/deploy/types.ts

@@ -34,7 +34,7 @@ export interface AppDeployResult {
 	/** App name */
 	appName: string;
 	/** App type */
-	type: 'backend' | 'frontend';
+	type: 'backend' | 'web' | 'mobile';
 	/** Whether deployment succeeded */
 	success: boolean;
 	/** Dokploy application ID */

package/src/dev/__tests__/index.spec.ts

@@ -455,13 +455,13 @@ describe('Workspace Dev Server', () => {
 					dependencies: [],
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3001,
 					dependencies: [],
 				},
 				admin: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/admin',
 					port: 3002,
 					dependencies: [],
@@ -481,7 +481,7 @@ describe('Workspace Dev Server', () => {
 					dependencies: [],
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3000, // Same port as api!
 					dependencies: [],
@@ -512,13 +512,13 @@ describe('Workspace Dev Server', () => {
 					dependencies: [],
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3001,
 					dependencies: [],
 				},
 				admin: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/admin',
 					port: 3001, // Conflicts with web
 					dependencies: [],
@@ -554,7 +554,7 @@ describe('Workspace Dev Server', () => {
 					dependencies: [],
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3001,
 					dependencies: [],
@@ -580,7 +580,7 @@ describe('Workspace Dev Server', () => {
 					dependencies: [],
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3002,
 					dependencies: ['api', 'auth'],
@@ -634,7 +634,7 @@ describe('Workspace Dev Server', () => {
 					dependencies: [],
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3001,
 					dependencies: ['api'],
@@ -669,13 +669,13 @@ describe('Workspace Dev Server', () => {
 					dependencies: ['auth'], // Payments depends on auth
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3003,
 					dependencies: ['api', 'auth'], // Web depends on api and auth
 				},
 				admin: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/admin',
 					port: 3004,
 					dependencies: ['api', 'payments'], // Admin depends on api and payments
@@ -1056,7 +1056,7 @@ describe('Workspace Dev Server', () => {
 						resolvedDeployTarget: 'dokploy',
 					},
 					web: {
-						type: 'frontend',
+						type: 'web',
 						path: 'apps/web',
 						port: 3001,
 						dependencies: ['api'],

package/src/dev/index.ts

@@ -856,7 +856,7 @@ export async function validateFrontendApps(
 	const results: FrontendValidationResult[] = [];
 
 	for (const [appName, app] of Object.entries(workspace.apps)) {
-		if (app.type === 'frontend') {
+		if (app.type === 'web') {
 			const result = await validateFrontendApp(
 				appName,
 				app.path,
@@ -920,13 +920,19 @@ async function workspaceDevCommand(
 		([_, app]) => app.type === 'backend',
 	);
 	const frontendApps = Object.entries(workspace.apps).filter(
-		([_, app]) => app.type === 'frontend',
+		([_, app]) => app.type === 'web',
+	);
+	const mobileApps = Object.entries(workspace.apps).filter(
+		([_, app]) => app.type === 'mobile',
 	);
 
 	logger.log(`\n🚀 Starting workspace: ${workspace.name}`);
-	logger.log(
-		`   ${backendApps.length} backend app(s), ${frontendApps.length} frontend app(s)`,
-	);
+	const counts = [
+		`${backendApps.length} backend`,
+		`${frontendApps.length} web`,
+	];
+	if (mobileApps.length > 0) counts.push(`${mobileApps.length} mobile`);
+	logger.log(`   ${counts.join(', ')} app(s)`);
 
 	// Check for port conflicts
 	const conflicts = checkPortConflicts(workspace);
@@ -1030,9 +1036,9 @@ async function workspaceDevCommand(
 			app.dependencies.length > 0
 				? ` (depends on: ${app.dependencies.join(', ')})`
 				: '';
-		logger.log(
-			`   ${app.type === 'backend' ? '🔧' : '🌐'} ${appName} → http://localhost:${app.port}${deps}`,
-		);
+		const icon =
+			app.type === 'backend' ? '🔧' : app.type === 'mobile' ? '📱' : '🌐';
+		logger.log(`   ${icon} ${appName} → http://localhost:${app.port}${deps}`);
 	}
 
 	// Find the config file path for GKM_CONFIG_PATH

package/src/docker/__tests__/compose.spec.ts

@@ -647,7 +647,7 @@ describe('generateWorkspaceCompose', () => {
 					resolvedDeployTarget: 'dokploy',
 				},
 				web: {
-					type: 'frontend',
+					type: 'web',
 					path: 'apps/web',
 					port: 3001,
 					dependencies: ['api'],
@@ -793,7 +793,7 @@ describe('generateWorkspaceCompose', () => {
 						resolvedDeployTarget: 'dokploy',
 					},
 					web: {
-						type: 'frontend',
+						type: 'web',
 						path: 'apps/web',
 						port: 3001,
 						dependencies: ['api', 'auth'],
@@ -849,7 +849,7 @@ describe('generateWorkspaceCompose', () => {
 			const workspace = createWorkspace({
 				apps: {
 					web: {
-						type: 'frontend',
+						type: 'web',
 						path: 'apps/web',
 						port: 3001,
 						dependencies: [],
@@ -1016,7 +1016,7 @@ describe('generateWorkspaceCompose', () => {
 			const workspace = createWorkspace({
 				apps: {
 					web: {
-						type: 'frontend',
+						type: 'web',
 						path: 'apps/web',
 						port: 3001,
 						dependencies: [],

package/src/docker/compose.ts

@@ -444,8 +444,10 @@ export function generateWorkspaceCompose(
 services:
 `;
 
-	// Generate service for each app
+	// Generate service for each app (mobile apps deploy via their own
+	// toolchain — no compose service)
 	for (const [appName, app] of apps) {
+		if (app.type === 'mobile') continue;
 		yaml += generateAppService(appName, app, apps, {
 			registry,
 			projectName: workspace.name,
@@ -698,9 +700,9 @@ function generateAppService(
 	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : '';
 
 	// Health check path - frontends use /, backends use /health
-	const healthCheckPath = app.type === 'frontend' ? '/' : '/health';
+	const healthCheckPath = app.type === 'web' ? '/' : '/health';
 	const healthCheckCmd =
-		app.type === 'frontend'
+		app.type === 'web'
 			? `["CMD", "wget", "-q", "--spider", "http://localhost:${app.port}/"]`
 			: `["CMD", "wget", "-q", "--spider", "http://localhost:${app.port}${healthCheckPath}"]`;
 

package/src/docker/index.ts

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, readFileSync, unlinkSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { loadConfig, loadWorkspaceConfig } from '../config';
+import { getPublicUrlArgNames } from '../deploy/domain.js';
 import type { NormalizedWorkspace } from '../workspace/types.js';
 import {
 	generateDockerCompose,
@@ -18,7 +19,9 @@ import {
 	generateEntryDockerfile,
 	generateMultiStageDockerfile,
 	generateNextjsDockerfile,
+	generateNodeWebDockerfile,
 	generateSlimDockerfile,
+	generateViteStaticDockerfile,
 	hasTurboConfig,
 	isMonorepo,
 	resolveDockerConfig,
@@ -342,7 +345,7 @@ async function pushDockerImage(
  */
 export interface AppDockerResult {
 	appName: string;
-	type: 'backend' | 'frontend';
+	type: 'backend' | 'web' | 'mobile';
 	dockerfile: string;
 	imageName: string;
 }
@@ -396,6 +399,15 @@ export async function workspaceDockerCommand(
 
 	// Generate Dockerfile for each app
 	for (const [appName, app] of apps) {
+		// Mobile apps deploy via their own toolchain (e.g. EAS Build for Expo)
+		// — no Docker image is produced.
+		if (app.type === 'mobile') {
+			logger.log(
+				`\n   📱 Skipping Docker for ${appName} (mobile app — deploy via framework toolchain)`,
+			);
+			continue;
+		}
+
 		const appPath = app.path;
 		const fullAppPath = join(workspace.root, appPath);
 
@@ -411,16 +423,31 @@ export async function workspaceDockerCommand(
 
 		let dockerfile: string;
 
-		if (app.type === 'frontend') {
-			// Generate Next.js Dockerfile
-			dockerfile = generateNextjsDockerfile({
+		if (app.type === 'web') {
+			const publicUrlArgs = getPublicUrlArgNames(app);
+			const webOpts = {
 				imageName,
 				baseImage: 'node:22-alpine',
 				port: app.port,
 				appPath,
 				turboPackage,
 				packageManager,
-			});
+				publicUrlArgs,
+			};
+
+			switch (app.framework) {
+				case 'vite':
+					dockerfile = generateViteStaticDockerfile(webOpts);
+					break;
+				case 'tanstack-start':
+				case 'remix':
+					dockerfile = generateNodeWebDockerfile(webOpts);
+					break;
+				default:
+					// nextjs (and any unspecified web framework — schema requires
+					// a valid framework, so this is just a default).
+					dockerfile = generateNextjsDockerfile(webOpts);
+			}
 		} else if (app.entry) {
 			// Backend with custom entry point - use tsdown bundling
 			dockerfile = generateEntryDockerfile({
@@ -479,7 +506,8 @@ export async function workspaceDockerCommand(
 	);
 	logger.log('\n📋 Build commands:');
 	for (const result of results) {
-		const icon = result.type === 'backend' ? '⚙️' : '🌐';
+		const icon =
+			result.type === 'backend' ? '⚙️' : result.type === 'mobile' ? '📱' : '🌐';
 		logger.log(
 			`   ${icon} docker build -f .gkm/docker/Dockerfile.${result.appName} -t ${result.imageName} .`,
 		);

package/src/docker/templates.ts

@@ -927,3 +927,141 @@ ENTRYPOINT ["/sbin/tini", "--"]
 CMD ["node", "index.mjs"]
 `;
 }
+
+/**
+ * Generate a Dockerfile for Node-based SSR web frameworks (TanStack Start,
+ * Remix). Builds with turbo, then runs the framework's production start
+ * script via `npm start`.
+ *
+ * Public URL build args are declared so framework bundlers (Vite, Vinxi)
+ * can inline them at build time. Per-framework prefix is the caller's job.
+ * @internal Exported for testing
+ */
+export function generateNodeWebDockerfile(
+	options: FrontendDockerfileOptions,
+): string {
+	const {
+		baseImage,
+		port,
+		appPath,
+		turboPackage,
+		packageManager,
+		publicUrlArgs = [],
+	} = options;
+
+	const pm = getPmConfig(packageManager);
+	const installPm = pm.install ? `RUN ${pm.install}` : '';
+	const turboInstallCmd = getTurboInstallCmd(packageManager);
+	const turboCmd = packageManager === 'pnpm' ? 'pnpm dlx turbo' : 'npx turbo';
+	const startCmd =
+		packageManager === 'pnpm'
+			? 'pnpm start'
+			: `${pm.lockfile.startsWith('package-lock') ? 'npm' : packageManager} start`;
+
+	const argDecls = publicUrlArgs.map((a) => `ARG ${a}=""`).join('\n');
+	const envDecls = publicUrlArgs.map((a) => `ENV ${a}=$${a}`).join('\n');
+
+	return `# syntax=docker/dockerfile:1
+# Node SSR web Dockerfile (TanStack Start / Remix) with turbo prune
+
+FROM ${baseImage} AS pruner
+WORKDIR /app
+${installPm}
+COPY . .
+RUN ${turboCmd} prune ${turboPackage} --docker
+
+FROM ${baseImage} AS deps
+WORKDIR /app
+${installPm}
+COPY --from=pruner /app/out/${pm.lockfile} ./
+COPY --from=pruner /app/out/json/ ./
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${turboInstallCmd}
+
+FROM deps AS builder
+WORKDIR /app
+${argDecls}
+${envDecls}
+COPY --from=pruner /app/out/full/ ./
+COPY --from=pruner /app/tsconfig.* ./
+RUN ${turboCmd} run build --filter=${turboPackage}
+
+FROM ${baseImage} AS runner
+WORKDIR /app
+RUN apk add --no-cache tini
+RUN addgroup --system --gid 1001 nodejs && \\
+    adduser --system --uid 1001 app
+
+# Copy the whole built workspace — frameworks differ on output paths
+COPY --from=builder --chown=app:nodejs /app/ ./
+
+ENV NODE_ENV=production
+ENV PORT=${port}
+ENV HOSTNAME="0.0.0.0"
+
+USER app
+EXPOSE ${port}
+
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["sh", "-c", "cd ${appPath} && ${startCmd}"]
+`;
+}
+
+/**
+ * Generate a Dockerfile for Vite SPA apps. Builds the static bundle with
+ * turbo, then serves it via nginx.
+ * @internal Exported for testing
+ */
+export function generateViteStaticDockerfile(
+	options: FrontendDockerfileOptions,
+): string {
+	const {
+		baseImage,
+		port,
+		appPath,
+		turboPackage,
+		packageManager,
+		publicUrlArgs = [],
+	} = options;
+
+	const pm = getPmConfig(packageManager);
+	const installPm = pm.install ? `RUN ${pm.install}` : '';
+	const turboInstallCmd = getTurboInstallCmd(packageManager);
+	const turboCmd = packageManager === 'pnpm' ? 'pnpm dlx turbo' : 'npx turbo';
+
+	const argDecls = publicUrlArgs.map((a) => `ARG ${a}=""`).join('\n');
+	const envDecls = publicUrlArgs.map((a) => `ENV ${a}=$${a}`).join('\n');
+
+	return `# syntax=docker/dockerfile:1
+# Vite SPA Dockerfile — builds static assets, serves via nginx
+
+FROM ${baseImage} AS pruner
+WORKDIR /app
+${installPm}
+COPY . .
+RUN ${turboCmd} prune ${turboPackage} --docker
+
+FROM ${baseImage} AS deps
+WORKDIR /app
+${installPm}
+COPY --from=pruner /app/out/${pm.lockfile} ./
+COPY --from=pruner /app/out/json/ ./
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${turboInstallCmd}
+
+FROM deps AS builder
+WORKDIR /app
+${argDecls}
+${envDecls}
+COPY --from=pruner /app/out/full/ ./
+COPY --from=pruner /app/tsconfig.* ./
+RUN ${turboCmd} run build --filter=${turboPackage}
+
+FROM nginx:alpine AS runner
+COPY --from=builder /app/${appPath}/dist /usr/share/nginx/html
+RUN printf 'server {\\n  listen ${port};\\n  root /usr/share/nginx/html;\\n  index index.html;\\n  location / { try_files $uri $uri/ /index.html; }\\n}\\n' \\
+    > /etc/nginx/conf.d/default.conf
+EXPOSE ${port}
+CMD ["nginx", "-g", "daemon off;"]
+`;
+}

package/src/generators/OpenApiTsGenerator.ts

@@ -1,5 +1,6 @@
 import type { Endpoint } from '@geekmidas/constructs/endpoints';
 import {
+	getRegisteredZodJsonSchemas,
 	getSchemaMetadata,
 	StandardSchemaJsonSchema,
 } from '@geekmidas/schema/conversion';
@@ -313,6 +314,27 @@ export class OpenApiTsGenerator {
 			}
 		}
 
+		// Pull in every schema registered via `.meta({ id })` in zod's global
+		// registry, even when no endpoint references it directly. This makes
+		// derived schemas like `UserSchema.pick(...)` discoverable through the
+		// named parent type without requiring the parent to be wired into an
+		// endpoint.
+		const registrySchemas = await getRegisteredZodJsonSchemas();
+		for (const [rawName, rawSchema] of Object.entries(registrySchemas)) {
+			const defName = this.pascalCase(rawName);
+			if (collectedDefs.has(defName) || generatedNames.has(defName)) {
+				continue;
+			}
+			const {
+				id: _id,
+				$defs: _defs,
+				...rest
+			} = rawSchema as JsonSchema & {
+				id?: string;
+			};
+			collectedDefs.set(defName, rest as JsonSchema);
+		}
+
 		// Generate interfaces for collected $defs (nested schemas with .meta({ id: 'X' }))
 		for (const [defName, defSchema] of collectedDefs) {
 			if (!generatedNames.has(defName)) {

package/src/generators/__tests__/OpenApiTsGenerator.registry.spec.ts

@@ -0,0 +1,98 @@
+import { e } from '@geekmidas/constructs/endpoints';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { OpenApiTsGenerator } from '../OpenApiTsGenerator';
+
+describe('OpenApiTsGenerator — zod global registry', () => {
+	beforeEach(() => {
+		z.globalRegistry.clear();
+	});
+
+	afterEach(() => {
+		z.globalRegistry.clear();
+	});
+
+	it('emits a named interface for a registered schema even when no endpoint references it directly', async () => {
+		const UserSchema = z
+			.object({
+				id: z.string(),
+				email: z.string(),
+				name: z.string(),
+			})
+			.meta({ id: 'User' });
+
+		const UserResponseSchema = UserSchema.pick({
+			id: true,
+			name: true,
+			email: true,
+		});
+
+		const endpoint = e
+			.get('/users/:id')
+			.output(UserResponseSchema)
+			.handle(async () => ({ id: '1', name: 'a', email: 'a@b.c' }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		expect(content).toMatch(/export interface User\b/);
+	});
+
+	it('does not duplicate when the same id is also produced by an endpoint', async () => {
+		const UserSchema = z
+			.object({
+				id: z.string(),
+				email: z.string(),
+				name: z.string(),
+			})
+			.meta({ id: 'User' });
+
+		const endpoint = e
+			.get('/users/:id')
+			.output(UserSchema)
+			.handle(async () => ({ id: '1', name: 'a', email: 'a@b.c' }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		const occurrences = content.match(/export interface User\b/g) ?? [];
+		expect(occurrences.length).toBe(1);
+	});
+
+	it('emits multiple registered schemas', async () => {
+		z.object({ id: z.string() }).meta({ id: 'Foo' });
+		z.object({ id: z.string() }).meta({ id: 'Bar' });
+
+		const endpoint = e
+			.get('/ping')
+			.output(z.object({ ok: z.boolean() }))
+			.handle(async () => ({ ok: true }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		expect(content).toMatch(/export interface Foo\b/);
+		expect(content).toMatch(/export interface Bar\b/);
+	});
+
+	it('references one registered schema from another via the parent type', async () => {
+		const UserSchema = z
+			.object({ id: z.string(), email: z.string() })
+			.meta({ id: 'User' });
+
+		z.object({ user: UserSchema, role: z.string() }).meta({ id: 'UserRole' });
+
+		const endpoint = e
+			.get('/ping')
+			.output(z.object({ ok: z.boolean() }))
+			.handle(async () => ({ ok: true }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		expect(content).toMatch(/export interface User\b/);
+		expect(content).toMatch(/export interface UserRole\b/);
+		// `user` inside UserRole should reference the named User type, not inline.
+		expect(content).toMatch(/user:\s*User\b/);
+	});
+});