@geekmidas/cli 10.0.0-alpha.69 → 10.0.0-alpha.71

package/dist/{OpenApiTsGenerator-CSaXs-dB.mjs → OpenApiTsGenerator-Bhr_XWWN.mjs}

@@ -4,579 +4,6 @@ import { existsSync, realpathSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { Endpoint } from "@geekmidas/constructs/endpoints";
 import { StandardSchemaJsonSchema, getRegisteredZodJsonSchemas, getSchemaMetadata } from "@geekmidas/schema/conversion";
-//#region src/build/endpoint-analyzer.ts
-/**
-* Analyze an endpoint to extract its features
-*/
-function analyzeEndpointFeatures(endpoint) {
-	return {
-		hasAuth: !!endpoint.authorizer || endpoint.hasSession === true,
-		hasServices: endpoint.services.length > 0,
-		hasDatabase: !!endpoint.databaseService,
-		hasBodyValidation: !!endpoint.input?.body,
-		hasQueryValidation: !!endpoint.input?.query,
-		hasParamValidation: !!endpoint.input?.params,
-		hasAudits: (endpoint.audits?.length ?? 0) > 0,
-		hasEvents: (endpoint.events?.length ?? 0) > 0,
-		hasRateLimit: !!endpoint.rateLimit,
-		hasRls: !!endpoint.rlsConfig && !endpoint.rlsBypass,
-		hasOutputValidation: !!endpoint.outputSchema
-	};
-}
-/**
-* Determine the optimization tier for an endpoint based on its features
-*/
-function determineEndpointTier(features) {
-	const { hasAuth, hasServices, hasDatabase, hasAudits, hasEvents, hasRateLimit, hasRls } = features;
-	if (!hasAuth && !hasServices && !hasDatabase && !hasAudits && !hasEvents && !hasRateLimit && !hasRls) return "minimal";
-	if (hasAudits || hasRls || hasRateLimit) return "full";
-	return "standard";
-}
-/**
-* Perform complete analysis of an endpoint
-*/
-function analyzeEndpoint(endpoint, exportName) {
-	const features = analyzeEndpointFeatures(endpoint);
-	const tier = determineEndpointTier(features);
-	return {
-		route: endpoint.route,
-		method: endpoint.method,
-		exportName,
-		features,
-		tier,
-		serviceNames: endpoint.services.map((s) => s.serviceName),
-		databaseServiceName: endpoint.databaseService?.serviceName
-	};
-}
-/**
-* Generate a summary of endpoint analysis for logging
-*/
-function summarizeAnalysis(analyses) {
-	const byTier = {
-		minimal: 0,
-		standard: 0,
-		full: 0
-	};
-	const byFeature = {
-		hasAuth: 0,
-		hasServices: 0,
-		hasDatabase: 0,
-		hasBodyValidation: 0,
-		hasQueryValidation: 0,
-		hasParamValidation: 0,
-		hasAudits: 0,
-		hasEvents: 0,
-		hasRateLimit: 0,
-		hasRls: 0,
-		hasOutputValidation: 0
-	};
-	for (const analysis of analyses) {
-		byTier[analysis.tier]++;
-		for (const [feature, enabled] of Object.entries(analysis.features)) if (enabled) byFeature[feature]++;
-	}
-	return {
-		total: analyses.length,
-		byTier,
-		byFeature
-	};
-}
-//#endregion
-//#region src/build/handler-templates.ts
-/**
-* Generate validator references for an endpoint
-*/
-function generateValidators(exportName, features) {
-	const validators = [];
-	if (features.hasBodyValidation) validators.push(`validateBody(${exportName})`);
-	if (features.hasQueryValidation) validators.push(`validateQuery(${exportName})`);
-	if (features.hasParamValidation) validators.push(`validateParams(${exportName})`);
-	return validators.length > 0 ? `\n    ${validators.join(",\n    ")},` : "";
-}
-/**
-* Generate a minimal handler (near-raw-Hono performance)
-*
-* Used for: Health checks, public endpoints with no services
-*/
-function generateMinimalHandler(analysis) {
-	const { exportName, features } = analysis;
-	const method = analysis.method.toLowerCase();
-	const validators = generateValidators(exportName, features);
-	if (!(validators.length > 0) && !features.hasOutputValidation) return `
-  // Minimal handler: ${analysis.route} (${analysis.method})
-  app.${method}('${analysis.route}', async (c) => {
-    const result = await ${exportName}.handler(
-      {
-        services: {},
-        logger,
-        body: undefined,
-        query: undefined,
-        params: undefined,
-        session: undefined,
-        header: Endpoint.createHeaders(c.req.header()),
-        cookie: Endpoint.createCookies(c.req.header().cookie),
-        auditor: undefined,
-        db: undefined,
-      } as any,
-      { getMetadata: () => ({}) } as any,
-    );
-    return c.json(result, ${exportName}.status as any);
-  });`;
-	return `
-  // Minimal handler with validation: ${analysis.route} (${analysis.method})
-  app.${method}('${analysis.route}',${validators}
-    async (c) => {
-      const result = await ${exportName}.handler(
-        {
-          services: {},
-          logger,
-          body: ${features.hasBodyValidation ? "(c.req.valid as any)('json')" : "undefined"},
-          query: ${features.hasQueryValidation ? "(c.req.valid as any)('query')" : "undefined"},
-          params: ${features.hasParamValidation ? "(c.req.valid as any)('param')" : "undefined"},
-          session: undefined,
-          header: Endpoint.createHeaders(c.req.header()),
-          cookie: Endpoint.createCookies(c.req.header().cookie),
-          auditor: undefined,
-          db: undefined,
-        } as any,
-        { getMetadata: () => ({}) } as any,
-      );
-      ${features.hasOutputValidation ? `const output = await ${exportName}.parseOutput(result);
-      return c.json(output, ${exportName}.status as any);` : `return c.json(result, ${exportName}.status as any);`}
-    }
-  );`;
-}
-/**
-* Generate a standard handler (auth and/or services)
-*
-* Used for: Authenticated endpoints, endpoints with services
-*/
-function generateStandardHandler(analysis) {
-	const { exportName, features } = analysis;
-	const method = analysis.method.toLowerCase();
-	const validators = generateValidators(exportName, features);
-	let serviceResolution = "";
-	if (features.hasServices || features.hasDatabase) serviceResolution = `
-      const services = await serviceDiscovery.register(${exportName}.services);
-      ${features.hasDatabase ? `const db = ${exportName}.databaseService
-        ? (await serviceDiscovery.register([${exportName}.databaseService]) as any)[${exportName}.databaseService.serviceName]
-        : undefined;` : "const db = undefined;"}`;
-	else serviceResolution = `
-      const services = {};
-      const db = undefined;`;
-	let authCode = "";
-	if (features.hasAuth) authCode = `
-      // Authentication
-      const session = await ${exportName}.getSession({
-        services,
-        logger,
-        header,
-        cookie,
-        ...(db !== undefined && { db }),
-      } as any);
-
-      const isAuthorized = await ${exportName}.authorize({
-        header,
-        cookie,
-        services,
-        logger,
-        session,
-      } as any);
-
-      if (!isAuthorized) {
-        return c.json({ error: 'Unauthorized' }, 401);
-      }`;
-	let eventCode = "";
-	if (features.hasEvents) eventCode = `
-      // Publish events on success
-      if (Endpoint.isSuccessStatus(${exportName}.status)) {
-        await (publishConstructEvents as any)(
-          ${exportName},
-          result,
-          serviceDiscovery,
-          logger,
-        );
-      }`;
-	return `
-  // Standard handler: ${analysis.route} (${analysis.method})
-  app.${method}('${analysis.route}',${validators}
-    async (c) => {
-      const headerValues = c.req.header();
-      const header = Endpoint.createHeaders(headerValues);
-      const cookie = Endpoint.createCookies(headerValues.cookie);
-${serviceResolution}
-${authCode}
-
-      const responseBuilder = new ResponseBuilder();
-      const result = await ${exportName}.handler(
-        {
-          services,
-          logger,
-          body: ${features.hasBodyValidation ? "(c.req.valid as any)('json')" : "undefined"},
-          query: ${features.hasQueryValidation ? "(c.req.valid as any)('query')" : "undefined"},
-          params: ${features.hasParamValidation ? "(c.req.valid as any)('param')" : "undefined"},
-          session: ${features.hasAuth ? "session" : "undefined"},
-          header,
-          cookie,
-          auditor: undefined,
-          db,
-        } as any,
-        responseBuilder,
-      );
-
-      let data = result;
-      let metadata = responseBuilder.getMetadata();
-
-      if (Endpoint.hasMetadata(result)) {
-        data = result.data;
-        metadata = result.metadata;
-      }
-
-      ${features.hasOutputValidation ? `const output = ${exportName}.outputSchema
-        ? await ${exportName}.parseOutput(data)
-        : data;` : "const output = data;"}
-${eventCode}
-
-      const status = (metadata.status ?? ${exportName}.status) as any;
-      return c.json(output, status);
-    }
-  );`;
-}
-/**
-* Generate validators.ts - Shared validator middleware factories
-*/
-function generateValidatorsFile(analyses) {
-	const needsBody = analyses.some((a) => a.features.hasBodyValidation);
-	const needsQuery = analyses.some((a) => a.features.hasQueryValidation);
-	const needsParams = analyses.some((a) => a.features.hasParamValidation);
-	if (!needsBody && !needsQuery && !needsParams) return `// No validators needed for this build\nexport {};\n`;
-	const exports = [];
-	const factories = [];
-	if (needsBody) {
-		exports.push("validateBody");
-		factories.push(`
-export const validateBody = (endpoint: any) =>
-  validator('json', async (value, c) => {
-    if (!endpoint.input?.body) return undefined;
-    const parsed = await Endpoint.validate(endpoint.input.body, value);
-    if (parsed.issues) return c.json(parsed.issues, 422);
-    return parsed.value;
-  });`);
-	}
-	if (needsQuery) {
-		exports.push("validateQuery");
-		factories.push(`
-export const validateQuery = (endpoint: any) =>
-  validator('query', async (_, c) => {
-    if (!endpoint.input?.query) return undefined;
-    const rawQuery = Object.fromEntries(new URL(c.req.url).searchParams);
-    const parsed = await Endpoint.validate(endpoint.input.query, rawQuery);
-    if (parsed.issues) return c.json(parsed.issues, 422);
-    return parsed.value;
-  });`);
-	}
-	if (needsParams) {
-		exports.push("validateParams");
-		factories.push(`
-export const validateParams = (endpoint: any) =>
-  validator('param', async (params, c) => {
-    if (!endpoint.input?.params) return undefined;
-    const parsed = await Endpoint.validate(endpoint.input.params, params);
-    if (parsed.issues) return c.json(parsed.issues, 422);
-    return parsed.value;
-  });`);
-	}
-	return `/**
- * Generated validator middleware factories
- * Shared across all endpoint tiers that need validation
- */
-import { validator } from 'hono/validator';
-import { Endpoint } from '@geekmidas/constructs/endpoints';
-${factories.join("\n")}
-`;
-}
-/**
-* Generate a standalone minimal endpoint file
-*/
-function generateMinimalEndpointFile(analysis, endpointImport) {
-	const { exportName, features } = analysis;
-	const validatorImport = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation ? generateValidatorImportsForEndpoint(analysis) : "";
-	const handler = generateMinimalHandler(analysis);
-	return `/**
- * Minimal endpoint: ${analysis.route} (${analysis.method})
- * Near-raw-Hono performance
- */
-import type { Hono } from 'hono';
-import type { Logger } from '@geekmidas/logger';
-import { Endpoint } from '@geekmidas/constructs/endpoints';
-${validatorImport}
-import { ${exportName} } from '${endpointImport.importPath}';
-
-export function setup${capitalize(exportName)}(
-  app: Hono,
-  logger: Logger,
-): void {
-${handler}
-}
-`;
-}
-/**
-* Generate a standalone standard endpoint file
-*/
-function generateStandardEndpointFile(analysis, endpointImport) {
-	const { exportName, features } = analysis;
-	const validatorImport = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation ? generateValidatorImportsForEndpoint(analysis) : "";
-	const eventsImport = features.hasEvents ? `import { publishConstructEvents } from '@geekmidas/constructs/endpoints';` : "";
-	const handler = generateStandardHandler(analysis);
-	return `/**
- * Standard endpoint: ${analysis.route} (${analysis.method})
- * Auth and/or services enabled
- */
-import type { Hono } from 'hono';
-import type { Logger } from '@geekmidas/logger';
-import type { ServiceDiscovery } from '@geekmidas/services';
-import { Endpoint, ResponseBuilder } from '@geekmidas/constructs/endpoints';
-${eventsImport}
-${validatorImport}
-import { ${exportName} } from '${endpointImport.importPath}';
-
-export function setup${capitalize(exportName)}(
-  app: Hono,
-  serviceDiscovery: ServiceDiscovery<any, any>,
-  logger: Logger,
-): void {
-${handler}
-}
-`;
-}
-/**
-* Generate a standalone full endpoint file
-*/
-function generateFullEndpointFile(analysis, endpointImport) {
-	const { exportName } = analysis;
-	return `/**
- * Full endpoint: ${analysis.route} (${analysis.method})
- * Complex features: audits, RLS, rate limiting
- */
-import type { Hono } from 'hono';
-import type { ServiceDiscovery } from '@geekmidas/services';
-import { HonoEndpoint } from '@geekmidas/constructs/hono';
-import { ${exportName} } from '${endpointImport.importPath}';
-
-export function setup${capitalize(exportName)}(
-  app: Hono,
-  serviceDiscovery: ServiceDiscovery<any, any>,
-  openApiOptions: any,
-): void {
-  HonoEndpoint.addRoutes([${exportName}] as any, serviceDiscovery, app, openApiOptions);
-}
-`;
-}
-/**
-* Generate tier index file that imports and calls all endpoint setup functions
-*/
-function generateTierIndexFile(tier, analyses) {
-	const tierEndpoints = analyses.filter((a) => a.tier === tier);
-	if (tierEndpoints.length === 0) {
-		if (tier === "minimal") return `// No minimal-tier endpoints in this build
-import type { Hono } from 'hono';
-import type { Logger } from '@geekmidas/logger';
-
-export function setupMinimalEndpoints(
-  _app: Hono,
-  _logger: Logger,
-): void {
-  // No minimal endpoints
-}
-`;
-		if (tier === "standard") return `// No standard-tier endpoints in this build
-import type { Hono } from 'hono';
-import type { Logger } from '@geekmidas/logger';
-import type { ServiceDiscovery } from '@geekmidas/services';
-
-export function setupStandardEndpoints(
-  _app: Hono,
-  _serviceDiscovery: ServiceDiscovery<any, any>,
-  _logger: Logger,
-): void {
-  // No standard endpoints
-}
-`;
-		return `// No full-tier endpoints in this build
-import type { Hono } from 'hono';
-import type { ServiceDiscovery } from '@geekmidas/services';
-
-export function setupFullEndpoints(
-  _app: Hono,
-  _serviceDiscovery: ServiceDiscovery<any, any>,
-  _enableOpenApi: boolean,
-): void {
-  // No full endpoints
-}
-`;
-	}
-	const imports = tierEndpoints.map((a) => `import { setup${capitalize(a.exportName)} } from './${a.exportName}.js';`).join("\n");
-	if (tier === "minimal") {
-		const calls = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, logger);`).join("\n");
-		return `/**
- * Minimal-tier endpoint index (${tierEndpoints.length} endpoints)
- * Near-raw-Hono performance
- */
-import type { Hono } from 'hono';
-import type { Logger } from '@geekmidas/logger';
-${imports}
-
-export function setupMinimalEndpoints(
-  app: Hono,
-  logger: Logger,
-): void {
-${calls}
-}
-`;
-	}
-	if (tier === "standard") {
-		const calls = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, serviceDiscovery, logger);`).join("\n");
-		return `/**
- * Standard-tier endpoint index (${tierEndpoints.length} endpoints)
- * Auth and/or services enabled
- */
-import type { Hono } from 'hono';
-import type { Logger } from '@geekmidas/logger';
-import type { ServiceDiscovery } from '@geekmidas/services';
-${imports}
-
-export function setupStandardEndpoints(
-  app: Hono,
-  serviceDiscovery: ServiceDiscovery<any, any>,
-  logger: Logger,
-): void {
-${calls}
-}
-`;
-	}
-	const calls = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, serviceDiscovery, openApiOptions);`).join("\n");
-	return `/**
- * Full-tier endpoint index (${tierEndpoints.length} endpoints)
- * Complex features: audits, RLS, rate limiting
- */
-import type { Hono } from 'hono';
-import type { ServiceDiscovery } from '@geekmidas/services';
-${imports}
-
-export function setupFullEndpoints(
-  app: Hono,
-  serviceDiscovery: ServiceDiscovery<any, any>,
-  enableOpenApi: boolean,
-): void {
-  const openApiOptions: any = enableOpenApi ? {
-    docsPath: '/__docs',
-    openApiOptions: {
-      title: 'API Documentation',
-      version: '1.0.0',
-      description: 'Generated API documentation'
-    }
-  } : { docsPath: false };
-
-${calls}
-}
-`;
-}
-/**
-* Generate validator imports for a single endpoint
-*/
-function generateValidatorImportsForEndpoint(analysis) {
-	const imports = [];
-	if (analysis.features.hasBodyValidation) imports.push("validateBody");
-	if (analysis.features.hasQueryValidation) imports.push("validateQuery");
-	if (analysis.features.hasParamValidation) imports.push("validateParams");
-	if (imports.length === 0) return "";
-	return `import { ${imports.join(", ")} } from '../validators.js';`;
-}
-/**
-* Capitalize first letter
-*/
-function capitalize(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
-* Generate all endpoint files with nested folder structure (per-endpoint files)
-*/
-function generateEndpointFilesNested(analyses, endpointImports) {
-	const files = {
-		"validators.ts": generateValidatorsFile(analyses),
-		"minimal/index.ts": generateTierIndexFile("minimal", analyses),
-		"standard/index.ts": generateTierIndexFile("standard", analyses),
-		"full/index.ts": generateTierIndexFile("full", analyses),
-		"index.ts": generateNestedIndexFile(analyses)
-	};
-	for (const analysis of analyses) {
-		const endpointImport = endpointImports.find((i) => i.exportName === analysis.exportName);
-		if (!endpointImport) continue;
-		const fileName = `${analysis.tier}/${analysis.exportName}.ts`;
-		switch (analysis.tier) {
-			case "minimal":
-				files[fileName] = generateMinimalEndpointFile(analysis, endpointImport);
-				break;
-			case "standard":
-				files[fileName] = generateStandardEndpointFile(analysis, endpointImport);
-				break;
-			case "full": files[fileName] = generateFullEndpointFile(analysis, endpointImport);
-		}
-	}
-	return files;
-}
-/**
-* Generate index.ts for nested structure
-*/
-function generateNestedIndexFile(analyses) {
-	const minimalCount = analyses.filter((a) => a.tier === "minimal").length;
-	const standardCount = analyses.filter((a) => a.tier === "standard").length;
-	const fullCount = analyses.filter((a) => a.tier === "full").length;
-	return `/**
- * Generated optimized endpoints
- *
- * Build-time optimization tiers:
- * - minimal: ${minimalCount} endpoints (near-raw-Hono)
- * - standard: ${standardCount} endpoints (auth/services)
- * - full: ${fullCount} endpoints (audits/rls/rate-limit)
- */
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import type { Hono } from 'hono';
-import { ServiceDiscovery } from '@geekmidas/services';
-import { setupMinimalEndpoints } from './minimal/index.js';
-import { setupStandardEndpoints } from './standard/index.js';
-import { setupFullEndpoints } from './full/index.js';
-
-export async function setupEndpoints(
-  app: Hono,
-  envParser: EnvironmentParser<any>,
-  logger: Logger,
-  enableOpenApi: boolean = false,
-): Promise<void> {
-  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
-
-  // Minimal handlers (${minimalCount} endpoints) - near-raw-Hono performance
-  setupMinimalEndpoints(app, logger);
-
-  // Standard handlers (${standardCount} endpoints) - auth/services
-  setupStandardEndpoints(app, serviceDiscovery, logger);
-
-  // Full handlers (${fullCount} endpoints) - audits/rls/rate-limit
-  setupFullEndpoints(app, serviceDiscovery, enableOpenApi);
-
-  // Add Swagger UI if OpenAPI is enabled
-  if (enableOpenApi) {
-    try {
-      const { swaggerUI } = await import('@hono/swagger-ui');
-      app.get('/__docs/ui', swaggerUI({ url: '/__docs' }));
-    } catch {
-      // @hono/swagger-ui not installed, skip Swagger UI
-    }
-  }
-}
-`;
-}
-//#endregion
 //#region src/generators/telemetry.ts
 /**
 * Every package `@geekmidas/telescope/instrumentation` loads at runtime.
@@ -641,6 +68,13 @@ const HEADER = `/**
  * configure the rest.
  */
 
+import type { MiddlewareHandler } from 'hono';
+
+/** Requests whose spans would only be noise: health checks, by default. */
+export interface StartTelemetryOptions {
+  ignorePaths?: string[];
+}
+
 /** Telemetry was asked for and cannot start. The server runs without it. */
 export class TelemetryUnavailable extends Error {
   constructor(readonly reason: string, options?: { cause?: unknown }) {
@@ -654,7 +88,9 @@ export class TelemetryUnavailable extends Error {
 `;
 /**
 * The entry's `telemetry.ts`: a `startTelemetry()` the server awaits before it
-* imports the app, so the libraries the app loads are instrumented.
+* imports the app, so the libraries the app loads are instrumented. It returns
+* the Hono middleware that traces each request, or undefined when telemetry is
+* off — the server mounts it ahead of every route.
 *
 * Failing to start telemetry warns (a named `TelemetryUnavailable`, through
 * `process.emitWarning`) and never stops the server: an outage in observability
@@ -662,25 +98,32 @@ export class TelemetryUnavailable extends Error {
 */
 function generateTelemetryModule(telemetry) {
 	if (!telemetry?.available) return `${HEADER}
-export async function startTelemetry(): Promise<void> {
-  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return;
+export async function startTelemetry(
+  _options: StartTelemetryOptions = {},
+): Promise<MiddlewareHandler | undefined> {
+  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return undefined;
 
   process.emitWarning(
     new TelemetryUnavailable(
       'this server was built without @geekmidas/telescope and the @opentelemetry packages it needs. Add them to the app and rebuild.',
     ),
   );
+  return undefined;
 }
 `;
 	const options = [
 		`serviceName: ${JSON.stringify(telemetry.serviceName)},`,
 		...telemetry.serviceNamespace ? [`serviceNamespace: ${JSON.stringify(telemetry.serviceNamespace)},`] : [],
 		"deploymentEnvironment: process.env.STAGE,",
-		"handleSignals: false,"
+		"handleSignals: false,",
+		"instrumentPino: false,",
+		"incomingHttpSpans: false,"
 	];
 	return `${HEADER}
-export async function startTelemetry(): Promise<void> {
-  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return;
+export async function startTelemetry(
+  options: StartTelemetryOptions = {},
+): Promise<MiddlewareHandler | undefined> {
+  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return undefined;
 
   let instrumentation;
   try {
@@ -692,7 +135,7 @@ export async function startTelemetry(): Promise<void> {
         { cause },
       ),
     );
-    return;
+    return undefined;
   }
 
   instrumentation.setupTelemetry({
@@ -709,6 +152,13 @@ export async function startTelemetry(): Promise<void> {
       });
     });
   }
+
+  // A SERVER span per request, opened by the app itself rather than by
+  // hooking node:http: \`GET /users/:id\`, continuing an incoming traceparent,
+  // with the handler — its logs, fetches and queries — running inside it.
+  return instrumentation.honoTelemetryMiddleware({
+    ignorePaths: options.ignorePaths,
+  });
 }
 `;
 }
@@ -811,7 +261,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 		const routes = [];
 		if (constructs.length === 0) return routes;
 		if (target === "server") {
-			await this.generateEndpointsFile(outputDir, constructs, context);
+			await this.generateEndpointsFile(outputDir, constructs);
 			const appFile = await this.generateAppFile(outputDir, context);
 			routes.push({
 				path: "*",
@@ -847,7 +297,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 		await writeFile(handlerPath, this.generateAWSApiGatewayV2Handler(importPath, exportName, context.storageDrivers));
 		return handlerPath;
 	}
-	async generateEndpointsFile(outputDir, endpoints, context) {
+	async generateEndpointsFile(outputDir, endpoints) {
 		const endpointsPath = join(outputDir, "endpoints.ts");
 		const importsByFile = /* @__PURE__ */ new Map();
 		for (const { path, key } of endpoints) {
@@ -855,19 +305,16 @@ var EndpointGenerator = class extends ConstructGenerator {
 			if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
 			importsByFile.get(importPath)?.push(key);
 		}
-		const endpointImports = Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n");
-		const allExportNames = endpoints.map(({ key }) => key);
-		if (context.production?.enabled && context.production.optimizedHandlers) return this.generateOptimizedEndpointsFile(endpointsPath, endpoints, endpointImports, allExportNames);
 		const content = `import type { EnvironmentParser } from '@geekmidas/envkit';
 import type { Logger } from '@geekmidas/logger';
 import { HonoEndpoint } from '@geekmidas/constructs/hono';
 import { Endpoint } from '@geekmidas/constructs/endpoints';
 import { ServiceDiscovery } from '@geekmidas/services';
 import type { Hono } from 'hono';
-${endpointImports}
+${Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n")}
 
 export const endpoints: Endpoint<any, any, any, any, any, any, any, any, any, any, any, any>[] = [
-  ${allExportNames.join(",\n  ")}
+  ${endpoints.map(({ key }) => key).join(",\n  ")}
 ];
 
 export async function setupEndpoints(
@@ -904,41 +351,6 @@ export async function setupEndpoints(
 		await writeFile(endpointsPath, content);
 		return endpointsPath;
 	}
-	/**
-	* Generate optimized endpoints files with nested folder structure (per-endpoint files)
-	*/
-	async generateOptimizedEndpointsFile(endpointsPath, endpoints, _endpointImports, _allExportNames) {
-		const logger = console;
-		const outputDir = dirname(endpointsPath);
-		const endpointsDir = join(outputDir, "endpoints");
-		await mkdir(join(endpointsDir, "minimal"), { recursive: true });
-		await mkdir(join(endpointsDir, "standard"), { recursive: true });
-		await mkdir(join(endpointsDir, "full"), { recursive: true });
-		const analyses = endpoints.map(({ key, construct }) => analyzeEndpoint(construct, key));
-		const endpointImports = endpoints.map(({ key, path }) => {
-			const tierDir = join(endpointsDir, "standard");
-			return {
-				exportName: key,
-				importPath: relative(tierDir, path.relative).replace(/\.ts$/, ".js")
-			};
-		});
-		const summary = summarizeAnalysis(analyses);
-		logger.log(`\n📊 Endpoint Analysis:`);
-		logger.log(`   Total: ${summary.total} endpoints`);
-		logger.log(`   - Minimal (near-raw-Hono): ${summary.byTier.minimal} endpoints`);
-		logger.log(`   - Standard (auth/services): ${summary.byTier.standard} endpoints`);
-		logger.log(`   - Full (audits/rls/rate-limit): ${summary.byTier.full} endpoints`);
-		const files = generateEndpointFilesNested(analyses, endpointImports);
-		for (const [filename, content] of Object.entries(files)) {
-			const filePath = join(endpointsDir, filename);
-			await mkdir(dirname(filePath), { recursive: true });
-			await writeFile(filePath, content);
-		}
-		const endpointFiles = Object.keys(files).filter((f) => !f.endsWith("index.ts") && !f.endsWith("validators.ts")).length;
-		const indexFiles = Object.keys(files).filter((f) => f.endsWith("index.ts")).length;
-		logger.log(`   Generated ${endpointFiles} endpoint files + ${indexFiles} index files + validators.ts`);
-		return join(endpointsDir, "index.ts");
-	}
 	async generateAppFile(outputDir, context) {
 		if (context.production?.enabled) return this.generateProductionAppFile(outputDir, context);
 		const appPath = join(outputDir, "app.ts");
@@ -1009,7 +421,7 @@ import { ${databaseApi.database.exportName} as __introspectedDb } from '${import
     (honoApp as any).__injectWebSocket = injectWebSocket;
     logger.info('Telescope WebSocket enabled');
   } catch (e) {
-    logger.warn({ error: e }, 'WebSocket support not available - install @hono/node-ws for real-time updates');
+    logger.warn({ err: e }, 'WebSocket support not available - install @hono/node-ws for real-time updates');
   }
 ` : "";
 		let telescopeSetup = "";
@@ -1158,19 +570,19 @@ ${afterSetupCall}
       // Mount pushed subscribers' routes and start polled ones. What comes
       // back subscribes the routes, once the server can answer them.
       const subscribeForPush = await setupSubscribers(honoApp, envParser, logger).catch((error) => {
-        logger.error({ error }, 'Failed to start subscribers');
+        logger.error({ err: error }, 'Failed to start subscribers');
         return async (_port: number) => {};
       });
 
       // Start queue workers in background (non-blocking, local development only)
       await setupQueues(envParser, logger).catch((error) => {
-        logger.error({ error }, 'Failed to start queue workers');
+        logger.error({ err: error }, 'Failed to start queue workers');
       });
 
       // Schedule this app's crons. Caught like the others: a scheduler that
       // cannot start is not a reason for the HTTP server not to.
       await setupCrons(envParser, logger).catch((error) => {
-        logger.error({ error }, 'Failed to schedule crons');
+        logger.error({ err: error }, 'Failed to schedule crons');
       });
 
       logger.info({ port }, 'Starting server');
@@ -1246,19 +658,19 @@ export const handler = adapter.handler;
       // Mount pushed subscribers' routes and start polled ones. What comes
       // back subscribes the routes, once the server can answer them.
       const subscribeForPush = await setupSubscribers(honoApp, envParser, logger).catch((error) => {
-        logger.error({ error }, 'Failed to start subscribers');
+        logger.error({ err: error }, 'Failed to start subscribers');
         return async (_port: number) => {};
       });
 
       // Start queue workers in background
       await setupQueues(envParser, logger).catch((error) => {
-        logger.error({ error }, 'Failed to start queue workers');
+        logger.error({ err: error }, 'Failed to start queue workers');
       });
 
       // Schedule this app's crons. Caught like the others: a scheduler that
       // cannot start is not a reason for the HTTP server not to.
       await setupCrons(envParser, logger).catch((error) => {
-        logger.error({ error }, 'Failed to schedule crons');
+        logger.error({ err: error }, 'Failed to schedule crons');
       });
 ` : "";
 		const subscriberImport = includeSubscribers ? `import { setupSubscribers } from './subscribers.js';
@@ -1286,14 +698,13 @@ import { setupCrons } from './crons.js';` : "";
       if (typeof close === 'function') close.call(server, () => resolve());
       else resolve();
     });
-    await runShutdownHooks((error) => logger.error({ error }, 'Shutdown hook failed'));
+    await runShutdownHooks((error) => logger.error({ err: error }, 'Shutdown hook failed'));
     process.exit(0);
   };
 
   process.on('SIGTERM', shutdown);
   process.on('SIGINT', shutdown);
 ` : "";
-		const endpointsImportPath = production.optimizedHandlers ? "./endpoints/index.js" : "./endpoints.js";
 		const content = `/**
  * Generated production server application
  *
@@ -1305,7 +716,7 @@ import { setupCrons } from './crons.js';` : "";
  */
 import { Hono } from 'hono';
 import type { Hono as HonoType } from 'hono';
-${enableGracefulShutdown ? "import { runShutdownHooks } from '@geekmidas/constructs';\n" : ""}import { setupEndpoints } from '${endpointsImportPath}';
+${enableGracefulShutdown ? "import { runShutdownHooks } from '@geekmidas/constructs';\n" : ""}import { setupEndpoints } from './endpoints.js';
 ${subscriberImport}
 ${runtime.imports}
 ${runtime.bindings}
@@ -1362,7 +773,7 @@ export async function createApp(app?: HonoType): Promise<ServerApp> {
         http.statusCode as 500,
       );
     }
-    logger.error({ error }, 'Unhandled error');
+    logger.error({ err: error }, 'Unhandled error');
     return c.json({ message: 'Internal Server Error' }, 500);
   });
 ${cors.setup}${beforeSetupCall}
@@ -1407,28 +818,36 @@ export default createApp;
 	async generateProductionServerEntry(outputDir, context) {
 		const serverPath = join(outputDir, "server.ts");
 		await writeFile(join(outputDir, "telemetry.ts"), generateTelemetryModule(context.telemetry));
-		await writeFile(serverPath, `#!/usr/bin/env node
+		const content = `#!/usr/bin/env node
 /**
  * Production server entry point
  * Generated by 'gkm build --production'
  */
 import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
 import { startTelemetry } from './telemetry.js';
 
 // Before the app is imported, so the libraries it loads are instrumented.
-await startTelemetry();
+const requestSpans = await startTelemetry({
+  ignorePaths: [${JSON.stringify(context.production?.healthCheck ?? "/health")}, '/ready'],
+});
 
 const { createApp } = await import('./app.js');
 
 const port = Number(process.env.PORT) || 3000;
 
-const { start } = await createApp();
+// The span middleware goes on before any route, so every request runs in it.
+const app = new Hono();
+if (requestSpans) app.use('*', requestSpans);
+
+const { start } = await createApp(app);
 
 await start({
   port,
   serve: (app, port) => serve({ fetch: app.fetch, port }),
 });
-`);
+`;
+		await writeFile(serverPath, content);
 	}
 };
 //#endregion
@@ -1939,4 +1358,4 @@ function unknownType(name) {
 //#endregion
 export { telemetryFor as i, EndpointGenerator as n, runtimeFor as r, OpenApiTsGenerator as t };
 
-//# sourceMappingURL=OpenApiTsGenerator-CSaXs-dB.mjs.map
+//# sourceMappingURL=OpenApiTsGenerator-Bhr_XWWN.mjs.map