@geekmidas/cli 1.9.1 → 1.10.0

package/dist/index.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S npx tsx
 import { __require } from "./chunk-Duj1WY3L.mjs";
-import { getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-9IQIjwkQ.mjs";
-import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceAppInfo, loadWorkspaceConfig, parseModuleConfig } from "./config-DxASSNjr.mjs";
+import { getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-D4z4A4cq.mjs";
+import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceAppInfo, loadWorkspaceConfig, parseModuleConfig } from "./config-jsRYHOHU.mjs";
 import { getCredentialsPath, getDokployCredentials, getDokployRegistryId, getDokployToken, removeDokployCredentials, storeDokployCredentials, storeDokployRegistryId } from "./credentials-s1kLcIzK.mjs";
-import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-BYlyAbH3.mjs";
+import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, copyAllClients, copyClientToFrontends, generateOpenApi, getBackendOpenApiPath, isPartitionedRoutes, normalizeRoutes, openapiCommand, resolveOpenApiConfig } from "./openapi-DenF-okj.mjs";
 import { getKeyPath, maskPassword, readStageSecrets, secretsExist, setCustomSecret, toEmbeddableSecrets, writeStageSecrets } from "./storage-DmCbr6DI.mjs";
 import { DokployApi } from "./dokploy-api-2ldYoN3i.mjs";
 import { encryptSecrets } from "./encryption-BOH5M-f-.mjs";
@@ -35,7 +35,7 @@ import prompts from "prompts";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "1.9.0";
+var version = "1.9.1";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -133,7 +133,7 @@ var package_default = {
 
 //#endregion
 //#region src/auth/index.ts
-const logger$13 = console;
+const logger$12 = console;
 /**
 * Validate Dokploy token by making a test API call
 */
@@ -201,36 +201,36 @@ async function prompt$1(message, hidden = false) {
 async function loginCommand(options) {
 	const { service, token: providedToken, endpoint: providedEndpoint } = options;
 	if (service === "dokploy") {
-		logger$13.log("\n🔐 Logging in to Dokploy...\n");
+		logger$12.log("\n🔐 Logging in to Dokploy...\n");
 		let endpoint = providedEndpoint;
 		if (!endpoint) endpoint = await prompt$1("Dokploy URL (e.g., https://dokploy.example.com): ");
 		endpoint = endpoint.replace(/\/$/, "");
 		try {
 			new URL(endpoint);
 		} catch {
-			logger$13.error("Invalid URL format");
+			logger$12.error("Invalid URL format");
 			process.exit(1);
 		}
 		let token = providedToken;
 		if (!token) {
-			logger$13.log(`\nGenerate a token at: ${endpoint}/settings/profile\n`);
+			logger$12.log(`\nGenerate a token at: ${endpoint}/settings/profile\n`);
 			token = await prompt$1("API Token: ", true);
 		}
 		if (!token) {
-			logger$13.error("Token is required");
+			logger$12.error("Token is required");
 			process.exit(1);
 		}
-		logger$13.log("\nValidating credentials...");
+		logger$12.log("\nValidating credentials...");
 		const isValid = await validateDokployToken(endpoint, token);
 		if (!isValid) {
-			logger$13.error("\n✗ Invalid credentials. Please check your token and try again.");
+			logger$12.error("\n✗ Invalid credentials. Please check your token and try again.");
 			process.exit(1);
 		}
 		await storeDokployCredentials(token, endpoint);
-		logger$13.log("\n✓ Successfully logged in to Dokploy!");
-		logger$13.log(`  Endpoint: ${endpoint}`);
-		logger$13.log(`  Credentials stored in: ${getCredentialsPath()}`);
-		logger$13.log("\nYou can now use deploy commands without setting DOKPLOY_API_TOKEN.");
+		logger$12.log("\n✓ Successfully logged in to Dokploy!");
+		logger$12.log(`  Endpoint: ${endpoint}`);
+		logger$12.log(`  Credentials stored in: ${getCredentialsPath()}`);
+		logger$12.log("\nYou can now use deploy commands without setting DOKPLOY_API_TOKEN.");
 	}
 }
 /**
@@ -240,28 +240,28 @@ async function logoutCommand(options) {
 	const { service = "dokploy" } = options;
 	if (service === "all") {
 		const dokployRemoved = await removeDokployCredentials();
-		if (dokployRemoved) logger$13.log("\n✓ Logged out from all services");
-		else logger$13.log("\nNo stored credentials found");
+		if (dokployRemoved) logger$12.log("\n✓ Logged out from all services");
+		else logger$12.log("\nNo stored credentials found");
 		return;
 	}
 	if (service === "dokploy") {
 		const removed = await removeDokployCredentials();
-		if (removed) logger$13.log("\n✓ Logged out from Dokploy");
-		else logger$13.log("\nNo Dokploy credentials found");
+		if (removed) logger$12.log("\n✓ Logged out from Dokploy");
+		else logger$12.log("\nNo Dokploy credentials found");
 	}
 }
 /**
 * Show current login status
 */
 async function whoamiCommand() {
-	logger$13.log("\n📋 Current credentials:\n");
+	logger$12.log("\n📋 Current credentials:\n");
 	const dokploy = await getDokployCredentials();
 	if (dokploy) {
-		logger$13.log("  Dokploy:");
-		logger$13.log(`    Endpoint: ${dokploy.endpoint}`);
-		logger$13.log(`    Token: ${maskToken(dokploy.token)}`);
-	} else logger$13.log("  Dokploy: Not logged in");
-	logger$13.log(`\n  Credentials file: ${getCredentialsPath()}`);
+		logger$12.log("  Dokploy:");
+		logger$12.log(`    Endpoint: ${dokploy.endpoint}`);
+		logger$12.log(`    Token: ${maskToken(dokploy.token)}`);
+	} else logger$12.log("  Dokploy: Not logged in");
+	logger$12.log(`\n  Credentials file: ${getCredentialsPath()}`);
 }
 /**
 * Mask a token for display
@@ -347,7 +347,7 @@ function isEnabled(config$1) {
 var CronGenerator = class extends ConstructGenerator {
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-lambda";
-		const logger$14 = console;
+		const logger$13 = console;
 		const cronInfos = [];
 		if (constructs.length === 0 || provider !== "aws-lambda") return cronInfos;
 		const cronsDir = join(outputDir, "crons");
@@ -362,7 +362,7 @@ var CronGenerator = class extends ConstructGenerator {
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment()
 			});
-			logger$14.log(`Generated cron handler: ${key}`);
+			logger$13.log(`Generated cron handler: ${key}`);
 		}
 		return cronInfos;
 	}
@@ -398,7 +398,7 @@ var FunctionGenerator = class extends ConstructGenerator {
 	}
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-lambda";
-		const logger$14 = console;
+		const logger$13 = console;
 		const functionInfos = [];
 		if (constructs.length === 0 || provider !== "aws-lambda") return functionInfos;
 		const functionsDir = join(outputDir, "functions");
@@ -412,7 +412,7 @@ var FunctionGenerator = class extends ConstructGenerator {
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment()
 			});
-			logger$14.log(`Generated function handler: ${key}`);
+			logger$13.log(`Generated function handler: ${key}`);
 		}
 		return functionInfos;
 	}
@@ -445,11 +445,11 @@ var SubscriberGenerator = class extends ConstructGenerator {
 	}
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-lambda";
-		const logger$14 = console;
+		const logger$13 = console;
 		const subscriberInfos = [];
 		if (provider === "server") {
 			await this.generateServerSubscribersFile(outputDir, constructs);
-			logger$14.log(`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`);
+			logger$13.log(`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`);
 			return subscriberInfos;
 		}
 		if (constructs.length === 0) return subscriberInfos;
@@ -466,7 +466,7 @@ var SubscriberGenerator = class extends ConstructGenerator {
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment()
 			});
-			logger$14.log(`Generated subscriber handler: ${key}`);
+			logger$13.log(`Generated subscriber handler: ${key}`);
 		}
 		return subscriberInfos;
 	}
@@ -631,98 +631,6 @@ export async function setupSubscribers(
 	}
 };
 
-//#endregion
-//#region src/workspace/client-generator.ts
-const logger$12 = console;
-/**
-* Get frontend apps that depend on a backend app.
-*/
-function getDependentFrontends(workspace, backendAppName) {
-	const dependentApps = [];
-	for (const [appName, app] of Object.entries(workspace.apps)) if (app.type === "frontend" && app.dependencies.includes(backendAppName)) dependentApps.push(appName);
-	return dependentApps;
-}
-/**
-* Get the path to a backend's OpenAPI spec file.
-*/
-function getBackendOpenApiPath(workspace, backendAppName) {
-	const app = workspace.apps[backendAppName];
-	if (!app || app.type !== "backend") return null;
-	return join(workspace.root, app.path, ".gkm", "openapi.ts");
-}
-/**
-* Count endpoints in an OpenAPI spec content.
-*/
-function countEndpoints(content) {
-	const endpointMatches = content.match(/'(GET|POST|PUT|PATCH|DELETE)\s+\/[^']+'/g);
-	return endpointMatches?.length ?? 0;
-}
-/**
-* Copy the OpenAPI client from a backend to all dependent frontend apps.
-* Called when the backend's .gkm/openapi.ts file changes.
-*/
-async function copyClientToFrontends(workspace, backendAppName, options = {}) {
-	const log = options.silent ? () => {} : logger$12.log.bind(logger$12);
-	const results = [];
-	const backendApp = workspace.apps[backendAppName];
-	if (!backendApp || backendApp.type !== "backend") return results;
-	const openApiPath = join(workspace.root, backendApp.path, ".gkm", "openapi.ts");
-	if (!existsSync(openApiPath)) return results;
-	const content = await readFile(openApiPath, "utf-8");
-	const endpointCount = countEndpoints(content);
-	const dependentFrontends = getDependentFrontends(workspace, backendAppName);
-	for (const frontendAppName of dependentFrontends) {
-		const frontendApp = workspace.apps[frontendAppName];
-		if (!frontendApp || frontendApp.type !== "frontend") continue;
-		const clientOutput = frontendApp.client?.output;
-		if (!clientOutput) continue;
-		const result = {
-			frontendApp: frontendAppName,
-			backendApp: backendAppName,
-			outputPath: "",
-			endpointCount,
-			success: false
-		};
-		try {
-			const frontendPath = join(workspace.root, frontendApp.path);
-			const outputDir = join(frontendPath, clientOutput);
-			await mkdir(outputDir, { recursive: true });
-			const fileName = `${backendAppName}.ts`;
-			const outputPath = join(outputDir, fileName);
-			const backendRelPath = relative(dirname(outputPath), join(workspace.root, backendApp.path));
-			const clientContent = `/**
- * Auto-generated API client for ${backendAppName}
- * Generated from: ${backendRelPath}
- *
- * DO NOT EDIT - This file is automatically regenerated when backend schemas change.
- */
-
-${content}
-`;
-			await writeFile(outputPath, clientContent);
-			result.outputPath = outputPath;
-			result.success = true;
-			log(`📦 Copied client to ${frontendAppName} from ${backendAppName} (${endpointCount} endpoints)`);
-		} catch (error) {
-			result.error = error.message;
-		}
-		results.push(result);
-	}
-	return results;
-}
-/**
-* Copy clients from all backends to their dependent frontends.
-* Useful for initial setup or force refresh.
-*/
-async function copyAllClients(workspace, options = {}) {
-	const allResults = [];
-	for (const [appName, app] of Object.entries(workspace.apps)) if (app.type === "backend" && app.routes) {
-		const results = await copyClientToFrontends(workspace, appName, options);
-		allResults.push(...results);
-	}
-	return allResults;
-}
-
 //#endregion
 //#region src/dev/index.ts
 const logger$11 = console;
@@ -1982,22 +1890,58 @@ async function execCommand(commandArgs, options = {}) {
 //#endregion
 //#region src/build/manifests.ts
 const logger$10 = console;
+function isPartitioned(field) {
+	return !Array.isArray(field);
+}
+/**
+* Serialize a manifest field to a TypeScript string.
+* Flat arrays serialize as JSON arrays, partitioned fields as objects of arrays.
+*/
+function serializeField(field, indent = 2) {
+	if (Array.isArray(field)) return JSON.stringify(field, null, indent);
+	const entries = Object.entries(field).map(([key, value]) => `    ${JSON.stringify(key)}: ${JSON.stringify(value, null, indent)}`).join(",\n");
+	return `{\n${entries},\n  }`;
+}
+/**
+* Count total items across a manifest field (flat or partitioned).
+*/
+function countItems(field) {
+	if (Array.isArray(field)) return field.length;
+	return Object.values(field).reduce((sum, arr) => sum + arr.length, 0);
+}
+/**
+* Generate derived types for a construct field.
+* @param fieldName - The field name in the manifest (e.g., 'routes')
+* @param typeName - The exported type name (e.g., 'Route')
+* @param partitioned - Whether this field is partitioned
+*/
+function generateDerivedType(fieldName, typeName, partitioned) {
+	if (partitioned) {
+		const partitionTypeName = `${typeName}Partition`;
+		return [`export type ${partitionTypeName} = keyof typeof manifest.${fieldName};`, `export type ${typeName}<P extends ${partitionTypeName} = ${partitionTypeName}> = (typeof manifest.${fieldName})[P][number];`].join("\n");
+	}
+	return `export type ${typeName} = (typeof manifest.${fieldName})[number];`;
+}
 async function generateAwsManifest(outputDir, routes, functions, crons, subscribers) {
 	const manifestDir = join(outputDir, "manifest");
 	await mkdir(manifestDir, { recursive: true });
-	const awsRoutes = routes.filter((r) => r.method !== "ALL");
+	const awsRoutes = filterAllRoutes(routes);
+	const routesPartitioned = isPartitioned(awsRoutes);
+	const functionsPartitioned = isPartitioned(functions);
+	const cronsPartitioned = isPartitioned(crons);
+	const subscribersPartitioned = isPartitioned(subscribers);
 	const content = `export const manifest = {
-  routes: ${JSON.stringify(awsRoutes, null, 2)},
-  functions: ${JSON.stringify(functions, null, 2)},
-  crons: ${JSON.stringify(crons, null, 2)},
-  subscribers: ${JSON.stringify(subscribers, null, 2)},
+  routes: ${serializeField(awsRoutes)},
+  functions: ${serializeField(functions)},
+  crons: ${serializeField(crons)},
+  subscribers: ${serializeField(subscribers)},
 } as const;
 
 // Derived types
-export type Route = (typeof manifest.routes)[number];
-export type Function = (typeof manifest.functions)[number];
-export type Cron = (typeof manifest.crons)[number];
-export type Subscriber = (typeof manifest.subscribers)[number];
+${generateDerivedType("routes", "Route", routesPartitioned)}
+${generateDerivedType("functions", "Function", functionsPartitioned)}
+${generateDerivedType("crons", "Cron", cronsPartitioned)}
+${generateDerivedType("subscribers", "Subscriber", subscribersPartitioned)}
 
 // Useful union types
 export type Authorizer = Route['authorizer'];
@@ -2006,30 +1950,25 @@ export type RoutePath = Route['path'];
 `;
 	const manifestPath = join(manifestDir, "aws.ts");
 	await writeFile(manifestPath, content);
-	logger$10.log(`Generated AWS manifest with ${awsRoutes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`);
+	logger$10.log(`Generated AWS manifest with ${countItems(awsRoutes)} routes, ${countItems(functions)} functions, ${countItems(crons)} crons, ${countItems(subscribers)} subscribers`);
 	logger$10.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
 }
 async function generateServerManifest(outputDir, appInfo, routes, subscribers) {
 	const manifestDir = join(outputDir, "manifest");
 	await mkdir(manifestDir, { recursive: true });
-	const serverRoutes = routes.filter((r) => r.method !== "ALL").map((r) => ({
-		path: r.path,
-		method: r.method,
-		authorizer: r.authorizer
-	}));
-	const serverSubscribers = subscribers.map((s) => ({
-		name: s.name,
-		subscribedEvents: s.subscribedEvents
-	}));
+	const serverRoutes = mapRouteMetadata(filterAllRoutes(routes));
+	const serverSubscribers = mapSubscriberMetadata(subscribers);
+	const routesPartitioned = isPartitioned(serverRoutes);
+	const subscribersPartitioned = isPartitioned(serverSubscribers);
 	const content = `export const manifest = {
   app: ${JSON.stringify(appInfo, null, 2)},
-  routes: ${JSON.stringify(serverRoutes, null, 2)},
-  subscribers: ${JSON.stringify(serverSubscribers, null, 2)},
+  routes: ${serializeField(serverRoutes)},
+  subscribers: ${serializeField(serverSubscribers)},
 } as const;
 
 // Derived types
-export type Route = (typeof manifest.routes)[number];
-export type Subscriber = (typeof manifest.subscribers)[number];
+${generateDerivedType("routes", "Route", routesPartitioned)}
+${generateDerivedType("subscribers", "Subscriber", subscribersPartitioned)}
 
 // Useful union types
 export type Authorizer = Route['authorizer'];
@@ -2038,9 +1977,70 @@ export type RoutePath = Route['path'];
 `;
 	const manifestPath = join(manifestDir, "server.ts");
 	await writeFile(manifestPath, content);
-	logger$10.log(`Generated server manifest with ${serverRoutes.length} routes, ${serverSubscribers.length} subscribers`);
+	logger$10.log(`Generated server manifest with ${countItems(serverRoutes)} routes, ${countItems(serverSubscribers)} subscribers`);
 	logger$10.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
 }
+/**
+* Filter out 'ALL' method routes from a manifest field (flat or partitioned).
+*/
+function filterAllRoutes(routes) {
+	if (Array.isArray(routes)) return routes.filter((r) => r.method !== "ALL");
+	const result = {};
+	for (const [partition, partitionRoutes] of Object.entries(routes)) result[partition] = partitionRoutes.filter((r) => r.method !== "ALL");
+	return result;
+}
+/**
+* Map routes to server metadata (path, method, authorizer only).
+*/
+function mapRouteMetadata(routes) {
+	const mapFn = (r) => ({
+		path: r.path,
+		method: r.method,
+		authorizer: r.authorizer
+	});
+	if (Array.isArray(routes)) return routes.map(mapFn);
+	const result = {};
+	for (const [partition, partitionRoutes] of Object.entries(routes)) result[partition] = partitionRoutes.map(mapFn);
+	return result;
+}
+/**
+* Map subscribers to server metadata (name, subscribedEvents only).
+*/
+function mapSubscriberMetadata(subscribers) {
+	const mapFn = (s) => ({
+		name: s.name,
+		subscribedEvents: s.subscribedEvents
+	});
+	if (Array.isArray(subscribers)) return subscribers.map(mapFn);
+	const result = {};
+	for (const [partition, partitionSubs] of Object.entries(subscribers)) result[partition] = partitionSubs.map(mapFn);
+	return result;
+}
+
+//#endregion
+//#region src/build/partitions.ts
+const DEFAULT_PARTITION = "default";
+/**
+* Check if any construct across the given arrays has a non-undefined partition.
+* When true, the manifest should use the partitioned shape for that construct type.
+*/
+function hasPartitions(constructs) {
+	return constructs.some((c) => c.partition !== void 0);
+}
+/**
+* Group an info array by partition, using the partition values from
+* the corresponding construct array. Both arrays must be the same length
+* and in the same order.
+*/
+function groupInfosByPartition(infos, constructs) {
+	const groups = {};
+	for (let i = 0; i < infos.length; i++) {
+		const partition = constructs[i]?.partition ?? DEFAULT_PARTITION;
+		if (!groups[partition]) groups[partition] = [];
+		groups[partition].push(infos[i]);
+	}
+	return groups;
+}
 
 //#endregion
 //#region src/build/index.ts
@@ -2062,10 +2062,10 @@ async function buildCommand(options) {
 	const production = normalizeProductionConfig(options.production ?? false, productionConfigFromGkm);
 	if (production) logger$9.log(`🏭 Building for PRODUCTION`);
 	logger$9.log(`Building with providers: ${resolved.providers.join(", ")}`);
-	logger$9.log(`Loading routes from: ${config$1.routes}`);
-	if (config$1.functions) logger$9.log(`Loading functions from: ${config$1.functions}`);
-	if (config$1.crons) logger$9.log(`Loading crons from: ${config$1.crons}`);
-	if (config$1.subscribers) logger$9.log(`Loading subscribers from: ${config$1.subscribers}`);
+	logger$9.log(`Loading routes from: ${formatRoutes(config$1.routes)}`);
+	if (config$1.functions) logger$9.log(`Loading functions from: ${formatRoutes(config$1.functions)}`);
+	if (config$1.crons) logger$9.log(`Loading crons from: ${formatRoutes(config$1.crons)}`);
+	if (config$1.subscribers) logger$9.log(`Loading subscribers from: ${formatRoutes(config$1.subscribers)}`);
 	logger$9.log(`Using envParser: ${config$1.envParser}`);
 	const { path: envParserPath, importPattern: envParserImportPattern } = parseModuleConfig(config$1.envParser, "envParser");
 	const { path: loggerPath, importPattern: loggerImportPattern } = parseModuleConfig(config$1.logger, "logger");
@@ -2137,6 +2137,10 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 		subscriberGenerator.build(context, subscribers, outputDir, { provider })
 	]);
 	logger$9.log(`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`);
+	const manifestRoutes = assembleManifestField(routes, endpoints);
+	const manifestFunctions = assembleManifestField(functionInfos, functions);
+	const manifestCrons = assembleManifestField(cronInfos, crons);
+	const manifestSubscribers = assembleManifestField(subscriberInfos, subscribers);
 	if (provider === "server") {
 		const routeMetadata = await Promise.all(endpoints.map(async ({ construct }) => ({
 			path: construct._path,
@@ -2144,11 +2148,12 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 			handler: "",
 			authorizer: construct.authorizer?.name ?? "none"
 		})));
+		const serverRouteField = assembleManifestField(routeMetadata, endpoints);
 		const appInfo = {
 			handler: relative(process.cwd(), join(outputDir, "app.ts")),
 			endpoints: relative(process.cwd(), join(outputDir, "endpoints.ts"))
 		};
-		await generateServerManifest(rootOutputDir, appInfo, routeMetadata, subscriberInfos);
+		await generateServerManifest(rootOutputDir, appInfo, serverRouteField, manifestSubscribers);
 		let masterKey;
 		if (context.production?.bundle && !skipBundle) {
 			logger$9.log(`\n📦 Bundling production server...`);
@@ -2178,7 +2183,7 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 			}
 		}
 		return { masterKey };
-	} else await generateAwsManifest(rootOutputDir, routes, functionInfos, cronInfos, subscriberInfos);
+	} else await generateAwsManifest(rootOutputDir, manifestRoutes, manifestFunctions, manifestCrons, manifestSubscribers);
 	return {};
 }
 /**
@@ -2276,6 +2281,25 @@ function getAppOutputPath(workspace, _appName, app) {
 	if (app.type === "frontend") return join(appPath, ".next");
 	else return join(appPath, ".gkm");
 }
+/**
+* Format routes for logging, handling PartitionedRoutes.
+*/
+function formatRoutes(routes) {
+	if (isPartitionedRoutes(routes)) {
+		const paths = Array.isArray(routes.paths) ? routes.paths.join(", ") : routes.paths;
+		return `${paths} (partitioned)`;
+	}
+	return Array.isArray(routes) ? routes.join(", ") : routes;
+}
+/**
+* Assemble a ManifestField from build infos and constructs.
+* If any construct has a partition, returns a Record<string, T[]>.
+* Otherwise, returns a flat T[].
+*/
+function assembleManifestField(infos, constructs) {
+	if (!hasPartitions(constructs)) return infos;
+	return groupInfosByPartition(infos, constructs);
+}
 
 //#endregion
 //#region src/deploy/state.ts
@@ -4890,7 +4914,7 @@ async function sniffAppEnvironment(app, appName, workspacePath, options = {}) {
 		};
 	}
 	if (app.routes) {
-		const result = await sniffRouteFiles(app.routes, app.path, workspacePath);
+		const result = await sniffRouteFiles(normalizeRoutes(app.routes), app.path, workspacePath);
 		if (logWarnings && result.error) console.warn(`[sniffer] ${appName}: Route sniffing threw error (env vars still captured): ${result.error.message}`);
 		return {
 			appName,