@geekmidas/cli 10.0.0-alpha.4 → 10.0.0-alpha.40

package/dist/{openapi-kkQbsRVj.mjs → OpenApiTsGenerator-CEh3EKN3.mjs}

@@ -1,12 +1,8 @@
-import { ConstructGenerator, isPartitionedRoutes } from "./discover-CAlFgYec.mjs";
-import { loadWorkspaceConfig } from "./config-WRdsQYZK.mjs";
-import { dirname, join, relative } from "node:path";
+import { i as ConstructGenerator } from "./discover-BLhf7V_J.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { spawn } from "node:child_process";
+import { dirname, join, relative } from "node:path";
 import { Endpoint } from "@geekmidas/constructs/endpoints";
-import { fileURLToPath } from "node:url";
 import { StandardSchemaJsonSchema, getRegisteredZodJsonSchemas, getSchemaMetadata } from "@geekmidas/schema/conversion";
-
 //#region src/build/endpoint-analyzer.ts
 /**
 * Analyze an endpoint to extract its features
@@ -83,7 +79,6 @@ function summarizeAnalysis(analyses) {
 		byFeature
 	};
 }
-
 //#endregion
 //#region src/build/handler-templates.ts
 /**
@@ -105,8 +100,7 @@ function generateMinimalHandler(analysis) {
 	const { exportName, features } = analysis;
 	const method = analysis.method.toLowerCase();
 	const validators = generateValidators(exportName, features);
-	const hasValidators = validators.length > 0;
-	if (!hasValidators && !features.hasOutputValidation) return `
+	if (!(validators.length > 0) && !features.hasOutputValidation) return `
   // Minimal handler: ${analysis.route} (${analysis.method})
   app.${method}('${analysis.route}', async (c) => {
     const result = await ${exportName}.handler(
@@ -304,8 +298,7 @@ ${factories.join("\n")}
 */
 function generateMinimalEndpointFile(analysis, endpointImport) {
 	const { exportName, features } = analysis;
-	const needsValidators = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation;
-	const validatorImport = needsValidators ? generateValidatorImportsForEndpoint(analysis) : "";
+	const validatorImport = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation ? generateValidatorImportsForEndpoint(analysis) : "";
 	const handler = generateMinimalHandler(analysis);
 	return `/**
  * Minimal endpoint: ${analysis.route} (${analysis.method})
@@ -330,8 +323,7 @@ ${handler}
 */
 function generateStandardEndpointFile(analysis, endpointImport) {
 	const { exportName, features } = analysis;
-	const needsValidators = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation;
-	const validatorImport = needsValidators ? generateValidatorImportsForEndpoint(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 `/**
@@ -423,7 +415,7 @@ export function setupFullEndpoints(
 	}
 	const imports = tierEndpoints.map((a) => `import { setup${capitalize(a.exportName)} } from './${a.exportName}.js';`).join("\n");
 	if (tier === "minimal") {
-		const calls$1 = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, logger);`).join("\n");
+		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
@@ -436,12 +428,12 @@ export function setupMinimalEndpoints(
   app: Hono,
   logger: Logger,
 ): void {
-${calls$1}
+${calls}
 }
 `;
 	}
 	if (tier === "standard") {
-		const calls$1 = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, serviceDiscovery, logger);`).join("\n");
+		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
@@ -456,7 +448,7 @@ export function setupStandardEndpoints(
   serviceDiscovery: ServiceDiscovery<any, any>,
   logger: Logger,
 ): void {
-${calls$1}
+${calls}
 }
 `;
 	}
@@ -526,9 +518,7 @@ function generateEndpointFilesNested(analyses, endpointImports) {
 			case "standard":
 				files[fileName] = generateStandardEndpointFile(analysis, endpointImport);
 				break;
-			case "full":
-				files[fileName] = generateFullEndpointFile(analysis, endpointImport);
-				break;
+			case "full": files[fileName] = generateFullEndpointFile(analysis, endpointImport);
 		}
 	}
 	return files;
@@ -585,7 +575,6 @@ export async function setupEndpoints(
 }
 `;
 }
-
 //#endregion
 //#region src/generators/EndpointGenerator.ts
 /**
@@ -602,24 +591,21 @@ export async function setupEndpoints(
 *
 * Falls back to the configured paths for an app that declares no surface.
 */
-function runtimeFor(context, fromDir) {
-	const module = context.surface?.module;
+function runtimeFor(context, fromDir, owner) {
+	const module = owner ? context.owners?.[owner] ?? context.surface?.module : context.surface?.module;
 	if (module) {
 		const specifier = importSpecifier(fromDir, module.specifier);
 		return {
 			imports: `import { ${module.exportName} as __surface } from '${specifier}';`,
 			bindings: [
-				"// What this surface was declared with. Objects, not module paths:",
-				"// the entry imports the surface, so there is nothing to print.",
+				"// What this construct was declared with. Objects, not module paths:",
+				"// the entry imports the owner, so there is nothing to print.",
 				"const envParser = __surface.envParser;",
 				"const logger = __surface.logger;"
 			].join("\n")
 		};
 	}
-	return {
-		imports: [`import ${context.envParserImportPattern} from '${importSpecifier(fromDir, context.envParserPath)}';`, `import ${context.loggerImportPattern} from '${importSpecifier(fromDir, context.loggerPath)}';`].join("\n"),
-		bindings: ""
-	};
+	throw new Error(`No owner to take a logger and an environment parser from${owner ? ` for "${owner}"` : ""}. Build it from a \`RestApi\` or a \`Worker\`.`);
 }
 /** A relative specifier ESM will accept: always prefixed, never bare. */
 function importSpecifier(fromDir, target) {
@@ -734,8 +720,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 	async generateHandlerFile(outputDir, sourceFile, exportName, provider, _endpoint, context) {
 		const handlerFileName = `${exportName}.ts`;
 		const handlerPath = join(outputDir, handlerFileName);
-		const relativePath = relative(dirname(handlerPath), sourceFile);
-		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const importPath = relative(dirname(handlerPath), sourceFile).replace(/\.ts$/, ".js");
 		let content;
 		switch (provider) {
 			case "aws-apigatewayv1":
@@ -753,12 +738,10 @@ var EndpointGenerator = class extends ConstructGenerator {
 		return handlerPath;
 	}
 	async generateEndpointsFile(outputDir, endpoints, context) {
-		const endpointsFileName = "endpoints.ts";
-		const endpointsPath = join(outputDir, endpointsFileName);
+		const endpointsPath = join(outputDir, "endpoints.ts");
 		const importsByFile = /* @__PURE__ */ new Map();
 		for (const { path, key } of endpoints) {
-			const relativePath = relative(dirname(endpointsPath), path.relative);
-			const importPath = relativePath.replace(/\.ts$/, ".js");
+			const importPath = relative(dirname(endpointsPath), path.relative).replace(/\.ts$/, ".js");
 			if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
 			importsByFile.get(importPath)?.push(key);
 		}
@@ -773,7 +756,7 @@ import { ServiceDiscovery } from '@geekmidas/services';
 import type { Hono } from 'hono';
 ${endpointImports}
 
-export const endpoints: Endpoint<any, any, any, any, any, any, any, any, any, any, any, any, any, any>[] = [
+export const endpoints: Endpoint<any, any, any, any, any, any, any, any, any, any, any, any>[] = [
   ${allExportNames.join(",\n  ")}
 ];
 
@@ -824,11 +807,9 @@ export async function setupEndpoints(
 		const analyses = endpoints.map(({ key, construct }) => analyzeEndpoint(construct, key));
 		const endpointImports = endpoints.map(({ key, path }) => {
 			const tierDir = join(endpointsDir, "standard");
-			const relativePath = relative(tierDir, path.relative);
-			const importPath = relativePath.replace(/\.ts$/, ".js");
 			return {
 				exportName: key,
-				importPath
+				importPath: relative(tierDir, path.relative).replace(/\.ts$/, ".js")
 			};
 		});
 		const summary = summarizeAnalysis(analyses);
@@ -850,8 +831,7 @@ export async function setupEndpoints(
 	}
 	async generateAppFile(outputDir, context) {
 		if (context.production?.enabled) return this.generateProductionAppFile(outputDir, context);
-		const appFileName = "app.ts";
-		const appPath = join(outputDir, appFileName);
+		const appPath = join(outputDir, "app.ts");
 		const runtime = runtimeFor(context, dirname(appPath));
 		const telescopeEnabled = context.telescope?.enabled;
 		const telescopeWebSocketEnabled = context.telescope?.websocket;
@@ -861,32 +841,36 @@ export async function setupEndpoints(
 		const studioFromDatabase = !usesExternalStudio && !!context.studio?.database;
 		const telescopeFromSurface = !!context.surface?.module && !usesExternalTelescope;
 		let telescopeImports = "";
-		if (telescopeEnabled) if (telescopeFromSurface) telescopeImports = "import { createMiddleware, createUI } from '@geekmidas/telescope/hono';";
-		else if (usesExternalTelescope) {
-			const relativeTelescopePath = relative(dirname(appPath), context.telescope?.telescopePath);
-			telescopeImports = `import ${context.telescope?.telescopeImportPattern} from '${relativeTelescopePath}';
+		if (telescopeEnabled) {
+			if (telescopeFromSurface) telescopeImports = `import { Telescope, InMemoryStorage } from '@geekmidas/telescope';
+import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
+			else if (usesExternalTelescope) {
+				const relativeTelescopePath = relative(dirname(appPath), context.telescope?.telescopePath);
+				telescopeImports = `import ${context.telescope?.telescopeImportPattern} from '${relativeTelescopePath}';
 import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
-		} else telescopeImports = `import { Telescope, InMemoryStorage } from '@geekmidas/telescope';
+			} else telescopeImports = `import { Telescope, InMemoryStorage } from '@geekmidas/telescope';
 import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
+		}
 		let studioImports = "";
-		if (studioEnabled) if (usesExternalStudio) {
-			const relativeStudioPath = relative(dirname(appPath), context.studio?.studioPath);
-			studioImports = `import ${context.studio?.studioImportPattern} from '${relativeStudioPath}';
+		if (studioEnabled) {
+			if (usesExternalStudio) {
+				const relativeStudioPath = relative(dirname(appPath), context.studio?.studioPath);
+				studioImports = `import ${context.studio?.studioImportPattern} from '${relativeStudioPath}';
 import { createStudioApp } from '@geekmidas/studio/server/hono';`;
-		} else if (studioFromDatabase) {
-			const dbSpecifier = importSpecifier(dirname(appPath), context.studio.database.specifier);
-			studioImports = `import { snifferContext } from '@geekmidas/constructs';
+			} else if (studioFromDatabase) {
+				const dbSpecifier = importSpecifier(dirname(appPath), context.studio.database.specifier);
+				studioImports = `import { snifferContext } from '@geekmidas/constructs';
 import { Direction, InMemoryMonitoringStorage, Studio } from '@geekmidas/studio';
 import { ${context.studio.database.exportName} as __studioDb } from '${dbSpecifier}';
 import { createStudioApp } from '@geekmidas/studio/server/hono';`;
-		} else studioImports = "";
+			} else studioImports = "";
+		}
 		const cors = corsFor(context.surface);
 		let hooksImports = "";
 		let beforeSetupCall = "";
 		let afterSetupCall = "";
 		if (context.hooks?.serverHooksPath) {
-			const relativeHooksPath = relative(dirname(appPath), context.hooks.serverHooksPath);
-			hooksImports = `import * as serverHooks from '${relativeHooksPath}';`;
+			hooksImports = `import * as serverHooks from '${relative(dirname(appPath), context.hooks.serverHooksPath)}';`;
 			beforeSetupCall = `
   // Call beforeSetup hook if defined
   if (typeof serverHooks.beforeSetup === 'function') {
@@ -932,7 +916,8 @@ import { createStudioApp } from '@geekmidas/studio/server/hono';`;
   }
 ` : "";
 		let telescopeSetup = "";
-		if (telescopeEnabled) if (telescopeFromSurface || usesExternalTelescope) telescopeSetup = `
+		if (telescopeEnabled) {
+			if (telescopeFromSurface || usesExternalTelescope) telescopeSetup = `
 ${telescopeWebSocketSetupCode}
   // Add telescope middleware (before endpoints to capture all requests)
   honoApp.use('*', createMiddleware(telescope));
@@ -941,7 +926,7 @@ ${telescopeWebSocketSetupCode}
   const telescopeUI = createUI(telescope);
   honoApp.route('${context.telescope?.path}', telescopeUI);
 `;
-		else telescopeSetup = `
+			else telescopeSetup = `
   // Setup Telescope for debugging/monitoring
   const telescopeStorage = new InMemoryStorage({ maxEntries: ${context.telescope?.maxEntries} });
   const telescope = new Telescope({
@@ -959,6 +944,7 @@ ${telescopeWebSocketSetupCode}
   const telescopeUI = createUI(telescope);
   honoApp.route('${context.telescope?.path}', telescopeUI);
 `;
+		}
 		let studioSetup = "";
 		if (studioEnabled && studioFromDatabase) studioSetup = `
   // Studio, built from the declared database. The client comes from the
@@ -992,6 +978,7 @@ import type { Hono as HonoType } from 'hono';
 import { setupEndpoints } from './endpoints.js';
 import { setupSubscribers } from './subscribers.js';
 import { setupQueues } from './queues.js';
+import { setupCrons } from './crons.js';
 ${runtime.imports}
 ${telescopeImports}
 ${studioImports}
@@ -1000,7 +987,16 @@ ${cors.imports}
 ${context.storageDrivers?.imports ?? ""}
 
 ${runtime.bindings}
-${telescopeFromSurface ? "const telescope = __surface.telescope;" : ""}
+${telescopeEnabled && telescopeFromSurface ? `// The surface's own Telescope, or the one \`telescope\` config describes.
+const telescope =
+  __surface.telescope ??
+  new Telescope({
+    enabled: true,
+    path: '${context.telescope?.path}',
+    ignorePatterns: ${JSON.stringify(context.telescope?.ignore)},
+    recordBody: ${context.telescope?.recordBody},
+    storage: new InMemoryStorage({ maxEntries: ${context.telescope?.maxEntries} }),
+  });` : ""}
 
 ${context.storageDrivers?.setup ? `// Which storage drivers exist is the entry point's decision: the scheme in
 // each injected URL picks one, so no construct and no application module names
@@ -1069,9 +1065,11 @@ ${afterSetupCall}
 
       const port = options.port ?? 3000;
 
-      // Start subscribers in background (non-blocking, local development only)
-      await setupSubscribers(envParser, logger).catch((error) => {
+      // 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');
+        return async (_port: number) => {};
       });
 
       // Start queue workers in background (non-blocking, local development only)
@@ -1079,12 +1077,20 @@ ${afterSetupCall}
         logger.error({ 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.info({ port }, 'Starting server');
 
       // Start HTTP server using provided serve function
       await options.serve(honoApp, port);
 
       logger.info({ port }, 'Server started');
+
+      await subscribeForPush(port);
     }
   };
 }
@@ -1147,10 +1153,8 @@ export const handler = ${exportName};
 	* No dev tools (Telescope, Studio, WebSocket), includes health checks and graceful shutdown
 	*/
 	async generateProductionAppFile(outputDir, context) {
-		const appFileName = "app.ts";
-		const appPath = join(outputDir, appFileName);
-		const relativeLoggerPath = relative(dirname(appPath), context.loggerPath);
-		const relativeEnvParserPath = relative(dirname(appPath), context.envParserPath);
+		const appPath = join(outputDir, "app.ts");
+		const runtime = runtimeFor(context, dirname(appPath));
 		const production = context.production;
 		const healthCheckPath = production.healthCheck;
 		const enableGracefulShutdown = production.gracefulShutdown;
@@ -1161,8 +1165,7 @@ export const handler = ${exportName};
 		let beforeSetupCall = "";
 		let afterSetupCall = "";
 		if (context.hooks?.serverHooksPath) {
-			const relativeHooksPath = relative(dirname(appPath), context.hooks.serverHooksPath);
-			hooksImports = `import * as serverHooks from '${relativeHooksPath}';`;
+			hooksImports = `import * as serverHooks from '${relative(dirname(appPath), context.hooks.serverHooksPath)}';`;
 			beforeSetupCall = `
   // Call beforeSetup hook if defined
   if (typeof serverHooks.beforeSetup === 'function') {
@@ -1177,18 +1180,27 @@ export const handler = ${exportName};
 `;
 		}
 		const subscriberSetup = includeSubscribers ? `
-      // Start subscribers in background
-      await setupSubscribers(envParser, logger).catch((error) => {
+      // 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');
+        return async (_port: number) => {};
       });
 
       // Start queue workers in background
       await setupQueues(envParser, logger).catch((error) => {
         logger.error({ 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');
+      });
 ` : "";
 		const subscriberImport = includeSubscribers ? `import { setupSubscribers } from './subscribers.js';
-import { setupQueues } from './queues.js';` : "";
+import { setupQueues } from './queues.js';
+import { setupCrons } from './crons.js';` : "";
 		const gracefulShutdownCode = enableGracefulShutdown ? `
   // Graceful shutdown handling
   let isShuttingDown = false;
@@ -1204,7 +1216,6 @@ import { setupQueues } from './queues.js';` : "";
   process.on('SIGTERM', shutdown);
   process.on('SIGINT', shutdown);
 ` : "";
-		const endpointsImportPath = production.optimizedHandlers ? "./endpoints/index.js" : "./endpoints.js";
 		const content = `/**
  * Generated production server application
  *
@@ -1216,10 +1227,10 @@ import { setupQueues } from './queues.js';` : "";
  */
 import { Hono } from 'hono';
 import type { Hono as HonoType } from 'hono';
-import { setupEndpoints } from '${endpointsImportPath}';
+import { setupEndpoints } from '${production.optimizedHandlers ? "./endpoints/index.js" : "./endpoints.js"}';
 ${subscriberImport}
-import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
-import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+${runtime.imports}
+${runtime.bindings}
 ${hooksImports}
 ${cors.imports}
 ${context.storageDrivers?.imports ?? ""}
@@ -1267,6 +1278,7 @@ ${gracefulShutdownCode}${subscriberSetup}
       await options.serve(honoApp, port);
 
       logger.info({ port }, 'Production server started');
+${includeSubscribers ? "\n      await subscribeForPush(port);" : ""}
     }
   };
 }
@@ -1283,7 +1295,7 @@ export default createApp;
 	*/
 	async generateProductionServerEntry(outputDir) {
 		const serverPath = join(outputDir, "server.ts");
-		const content = `#!/usr/bin/env node
+		await writeFile(serverPath, `#!/usr/bin/env node
 /**
  * Production server entry point
  * Generated by 'gkm build --provider server --production'
@@ -1299,11 +1311,9 @@ await start({
   port,
   serve: (app, port) => { serve({ fetch: app.fetch, port }); },
 });
-`;
-		await writeFile(serverPath, content);
+`);
 	}
 };
-
 //#endregion
 //#region src/generators/OpenApiTsGenerator.ts
 /**
@@ -1458,7 +1468,7 @@ var OpenApiTsGenerator = class {
 		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;
+			const { id: _id, $defs: _defs, ...rest } = rawSchema;
 			collectedDefs.set(defName, rest);
 		}
 		for (const [defName, defSchema] of collectedDefs) if (!generatedNames.has(defName)) {
@@ -1494,17 +1504,17 @@ var OpenApiTsGenerator = class {
 	async schemaToInterfaceWithDefs(schema, name, collectedDefs) {
 		try {
 			const vendor = schema["~standard"]?.vendor;
-			if (!vendor || !(vendor in StandardSchemaJsonSchema)) return null;
+			if (!vendor || !(vendor in StandardSchemaJsonSchema)) return unknownType(name);
 			const toJsonSchema = StandardSchemaJsonSchema[vendor];
 			const jsonSchema = await toJsonSchema(schema);
-			if (!jsonSchema) return null;
+			if (!jsonSchema) return unknownType(name);
 			if (jsonSchema.$defs && typeof jsonSchema.$defs === "object") {
 				for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) if (!collectedDefs.has(defName)) {
-					const { id,...schemaWithoutId } = defSchema;
+					const { id, ...schemaWithoutId } = defSchema;
 					collectedDefs.set(defName, schemaWithoutId);
 				}
 			}
-			const { $defs,...schemaWithoutDefs } = jsonSchema;
+			const { $defs, ...schemaWithoutDefs } = jsonSchema;
 			const ref = schemaWithoutDefs.$ref;
 			if (ref && Object.keys(schemaWithoutDefs).every((k) => k === "$ref" || k === "$schema")) {
 				const target = ref.split("/").pop();
@@ -1512,14 +1522,11 @@ var OpenApiTsGenerator = class {
 			}
 			return this.jsonSchemaToInterface(schemaWithoutDefs, name);
 		} catch {
-			return null;
+			return unknownType(name);
 		}
 	}
 	jsonSchemaToInterface(schema, name) {
-		if (schema.type !== "object" || !schema.properties) {
-			const typeStr = this.jsonSchemaTypeToTs(schema);
-			return `export type ${name} = ${typeStr};`;
-		}
+		if (schema.type !== "object" || !schema.properties) return `export type ${name} = ${this.jsonSchemaTypeToTs(schema)};`;
 		const props = [];
 		const required = new Set(schema.required || []);
 		for (const [propName, propSchema] of Object.entries(schema.properties)) {
@@ -1532,13 +1539,15 @@ var OpenApiTsGenerator = class {
 	}
 	jsonSchemaTypeToTs(schema) {
 		if (!schema) return "unknown";
-		if (schema.$ref) {
-			const refName = schema.$ref.split("/").pop() || "unknown";
-			return refName;
-		}
+		if (schema.$ref) return schema.$ref.split("/").pop() || "unknown";
+		if (schema.const !== void 0) return typeof schema.const === "string" ? `'${schema.const}'` : String(schema.const);
 		if (schema.anyOf) return schema.anyOf.map((s) => this.jsonSchemaTypeToTs(s)).join(" | ");
 		if (schema.oneOf) return schema.oneOf.map((s) => this.jsonSchemaTypeToTs(s)).join(" | ");
 		if (schema.allOf) return schema.allOf.map((s) => this.jsonSchemaTypeToTs(s)).join(" & ");
+		if (Array.isArray(schema.type)) return schema.type.map((type) => this.jsonSchemaTypeToTs({
+			...schema,
+			type
+		})).join(" | ");
 		switch (schema.type) {
 			case "string":
 				if (schema.enum) return schema.enum.map((e) => `'${e}'`).join(" | ");
@@ -1562,10 +1571,7 @@ var OpenApiTsGenerator = class {
 					}
 					return `{ ${props.join("; ")} }`;
 				}
-				if (schema.additionalProperties) {
-					const valueType = this.jsonSchemaTypeToTs(schema.additionalProperties);
-					return `Record<string, ${valueType}>`;
-				}
+				if (schema.additionalProperties) return `Record<string, ${this.jsonSchemaTypeToTs(schema.additionalProperties)}>`;
 				return "Record<string, unknown>";
 			default: return "unknown";
 		}
@@ -1586,10 +1592,7 @@ var OpenApiTsGenerator = class {
 			}
 			const firstWithParams = infos.find((i) => i.input?.params);
 			let paramsEntry = "";
-			if (firstWithParams?.input?.params) {
-				const paramsName = await this.getSchemaName(firstWithParams.input.params, `${this.getSchemaBaseName(firstWithParams)}Params`);
-				paramsEntry = `\n    parameters: {\n      path: ${paramsName};\n    };`;
-			}
+			if (firstWithParams?.input?.params) paramsEntry = `\n    parameters: {\n      path: ${await this.getSchemaName(firstWithParams.input.params, `${this.getSchemaBaseName(firstWithParams)}Params`)};\n    };`;
 			pathEntries.push(`  '${route}': {${paramsEntry}\n${methodEntries.join("\n")}\n  };`);
 		}
 		return `export interface paths {\n${pathEntries.join("\n")}\n}`;
@@ -1628,8 +1631,7 @@ var OpenApiTsGenerator = class {
 			return acc;
 		}, {});
 		const schemeNames = securitySchemes.map((s) => `'${s.name}'`).join(" | ");
-		const hasSecuritySchemes = schemeNames.length > 0;
-		const createApiSection = hasSecuritySchemes ? `
+		const createApiSection = schemeNames.length > 0 ? `
 // ============================================================
 // API Client Factory
 // ============================================================
@@ -1653,6 +1655,8 @@ export interface CreateApiOptions {
   queryClient?: QueryClient;
   /** Optional request interceptor */
   onRequest?: (config: RequestInit) => RequestInit | Promise<RequestInit>;
+  /** The \`fetch\` requests go out on — a test browser's, for one */
+  fetch?: typeof fetch;
 }
 
 /**
@@ -1682,6 +1686,7 @@ export function createApi(options: CreateApiOptions) {
     securitySchemes,
     authStrategies: options.authStrategies,
     onRequest: options.onRequest,
+    ...(options.fetch ? { fetch: options.fetch } : {}),
   });
 
   const hooks = createEndpointHooks<paths>(fetcher, { queryClient: options.queryClient });
@@ -1806,162 +1811,15 @@ ${createApiSection}
 `;
 	}
 };
-
-//#endregion
-//#region src/workspace/client-generator.ts
 /**
-* Normalize routes to an array of patterns.
-* Handles string, string[], and PartitionedRoutes (extracts paths).
-* @internal Exported for use in dev command
+* The declaration for a schema that cannot be converted — a vendor with no
+* converter, or one that fails. The paths interface names it either way, so
+* leaving it undeclared made the generated client fail to compile.
 */
-function normalizeRoutes(routes) {
-	if (!routes) return [];
-	if (isPartitionedRoutes(routes)) return Array.isArray(routes.paths) ? routes.paths : [routes.paths];
-	return Array.isArray(routes) ? routes : [routes];
+function unknownType(name) {
+	return `export type ${name} = unknown;`;
 }
-
 //#endregion
-//#region src/openapi.ts
-/**
-* Default output path for generated OpenAPI client (used for single-app configs)
-*/
-const OPENAPI_OUTPUT_PATH = "./.gkm/openapi.ts";
-/**
-* Resolve OpenAPI config from GkmConfig
-*/
-function resolveOpenApiConfig(config) {
-	if (config.openapi === false) return { enabled: false };
-	if (config.openapi === true || config.openapi === void 0) return {
-		enabled: true,
-		title: "API Documentation",
-		version: "1.0.0",
-		description: "Auto-generated API documentation from endpoints"
-	};
-	return {
-		enabled: config.openapi.enabled !== false,
-		title: config.openapi.title || "API Documentation",
-		version: config.openapi.version || "1.0.0",
-		description: config.openapi.description || "Auto-generated API documentation from endpoints"
-	};
-}
-/**
-* Generate OpenAPI spec from endpoints
-* @returns Object with output path and endpoint count, or null if disabled
-*/
-async function generateOpenApi(config, options = {}) {
-	const logger = options.silent ? { log: () => {} } : console;
-	const openApiConfig = resolveOpenApiConfig(config);
-	if (!openApiConfig.enabled) return null;
-	const endpointGenerator = new EndpointGenerator();
-	const loadedEndpoints = await endpointGenerator.load(config.routes, void 0, options.bustCache);
-	if (loadedEndpoints.length === 0) {
-		logger.log("No valid endpoints found for OpenAPI generation");
-		return null;
-	}
-	const endpoints = loadedEndpoints.map(({ construct }) => construct);
-	const outputPath = join(process.cwd(), OPENAPI_OUTPUT_PATH);
-	await mkdir(dirname(outputPath), { recursive: true });
-	const tsGenerator = new OpenApiTsGenerator();
-	const tsContent = await tsGenerator.generate(endpoints, {
-		title: openApiConfig.title,
-		version: openApiConfig.version,
-		description: openApiConfig.description
-	});
-	await writeFile(outputPath, tsContent);
-	logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
-	return {
-		outputPath,
-		endpointCount: loadedEndpoints.length
-	};
-}
-async function openapiCommand(options = {}) {
-	const logger = console;
-	try {
-		const loadedConfig = await loadWorkspaceConfig(options.cwd);
-		if (loadedConfig.type === "single") {
-			const config = loadedConfig.raw;
-			if (!config.openapi) config.openapi = { enabled: true };
-			const result = await generateOpenApi(config);
-			if (result) logger.log(`Found ${result.endpointCount} endpoints`);
-		} else {
-			const { workspace } = loadedConfig;
-			const workspaceRoot = workspace.root;
-			const backendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "backend" && app.routes !== void 0 && app.openapi !== false && (typeof app.openapi !== "object" || app.openapi.enabled !== false));
-			if (backendApps.length === 0) {
-				logger.log("No backend apps with OpenAPI enabled found");
-				return;
-			}
-			if (options.app) {
-				const entry = backendApps.find(([name]) => name === options.app);
-				if (!entry) throw new Error(`App "${options.app}" not found or has OpenAPI disabled`);
-				const [appName, app] = entry;
-				const result = await generateOpenApiForApp(workspaceRoot, appName, app);
-				if (result) logger.log(`📄 [${appName}] Generated OpenAPI (${result.endpointCount} endpoints)`);
-				return;
-			}
-			for (const [appName, app] of backendApps) {
-				if (app.type !== "backend" || !app.routes) continue;
-				const appPath = join(workspaceRoot, app.path);
-				await runOpenApiInSubprocess(appPath, appName);
-			}
-		}
-	} catch (error) {
-		throw new Error(`OpenAPI generation failed: ${error.message}`);
-	}
-}
-/**
-* Generate OpenAPI for a single named app within a workspace.
-* Runs in-process. The caller is responsible for ensuring `process.cwd()`
-* is the app's directory so tsx loads the app's tsconfig path aliases.
-*/
-async function generateOpenApiForApp(workspaceRoot, _appName, app) {
-	if (app.type !== "backend" || !app.routes) return null;
-	const appPath = join(workspaceRoot, app.path);
-	const routes = normalizeRoutes(app.routes);
-	const routesGlob = routes.map((r) => join(appPath, r));
-	const gkmConfig = {
-		routes: routesGlob,
-		envParser: app.envParser || "",
-		logger: app.logger || "",
-		openapi: app.openapi
-	};
-	return generateOpenApi(gkmConfig, { silent: true });
-}
-/**
-* Resolve the gkm bin path. Tests can override via `GKM_BIN_PATH` env var
-* to avoid depending on the built dist.
-*/
-function resolveGkmBinPath() {
-	if (process.env.GKM_BIN_PATH) return process.env.GKM_BIN_PATH;
-	return fileURLToPath(new URL("../bin/gkm.mjs", import.meta.url));
-}
-/**
-* Spawn a subprocess that runs `gkm openapi --app <name>` with `cwd` set to
-* the app's directory. Inherits `NODE_OPTIONS` (which already contains
-* `--import tsx`), so the child gets a fresh tsx instance whose tsconfig
-* discovery picks up the app's tsconfig path aliases.
-*/
-async function runOpenApiInSubprocess(appCwd, appName) {
-	const binPath = resolveGkmBinPath();
-	await new Promise((resolve$1, reject) => {
-		const child = spawn(process.execPath, [
-			binPath,
-			"openapi",
-			"--app",
-			appName
-		], {
-			cwd: appCwd,
-			stdio: "inherit",
-			env: process.env
-		});
-		child.on("error", reject);
-		child.on("close", (code) => {
-			if (code === 0) resolve$1();
-			else reject(new Error(`OpenAPI generation for app "${appName}" exited with code ${code}`));
-		});
-	});
-}
+export { EndpointGenerator as n, runtimeFor as r, OpenApiTsGenerator as t };
 
-//#endregion
-export { EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, normalizeRoutes, openapiCommand, resolveOpenApiConfig };
-//# sourceMappingURL=openapi-kkQbsRVj.mjs.map
+//# sourceMappingURL=OpenApiTsGenerator-CEh3EKN3.mjs.map