@codemation/cli 0.0.15 → 0.0.18

package/dist/{CliBin-BkY_gChN.js → CliBin-BYHuUedo.js}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import process$1 from "node:process";
-import { AppConfigLoader, CodemationConsumerConfigLoader, CodemationFrontendAuthSnapshotFactory, CodemationPluginDiscovery, FrontendAppConfigJsonCodec, WorkflowDiscoveryPathSegmentsComputer, WorkflowModulePathFinder } from "@codemation/host/server";
-import { ApiPaths, AppContainerFactory, AppContainerLifecycle, ApplicationTokens, CodemationFrontendAuthSnapshotFactory as CodemationFrontendAuthSnapshotFactory$1, DatabaseMigrations, FrontendAppConfigJsonCodec as FrontendAppConfigJsonCodec$1, ListUserAccountsQuery, PrismaClient, UpsertLocalBootstrapUserCommand, WorkerRuntime } from "@codemation/host";
+import { AppConfigLoader, CodemationConsumerConfigLoader, CodemationPluginDiscovery, WorkflowDiscoveryPathSegmentsComputer, WorkflowModulePathFinder } from "@codemation/host/server";
+import { ApiPaths, AppContainerFactory, AppContainerLifecycle, ApplicationTokens, CodemationPluginPackageMetadata, DatabaseMigrations, ListUserAccountsQuery, PrismaClient, UpsertLocalBootstrapUserCommand, WorkerRuntime } from "@codemation/host";
 import { AppContainerFactory as AppContainerFactory$1, AppContainerLifecycle as AppContainerLifecycle$1, CodemationHonoApiApp, CodemationPluginListMerger, FrontendRuntime, ServerLoggerFactory, logLevelPolicyFactory } from "@codemation/host/next/server";
 import { randomUUID } from "node:crypto";
 import { access, copyFile, cp, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -25,6 +25,23 @@ import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createServer as createServer$1 } from "node:net";
 import { Command } from "commander";
 
+//#region src/build/ConsumerBuildOptionsParser.ts
+var ConsumerBuildOptionsParser = class {
+	parse(args) {
+		return {
+			sourceMaps: args.noSourceMaps !== true,
+			target: this.parseTarget(args.target)
+		};
+	}
+	parseTarget(raw) {
+		if (raw === void 0 || raw.trim() === "") return "es2022";
+		const normalized = raw.trim();
+		if (normalized === "es2020" || normalized === "es2022") return normalized;
+		throw new Error(`Invalid --target "${raw}". Use es2020 or es2022.`);
+	}
+};
+
+//#endregion
 //#region src/build/ConsumerBuildArtifactsPublisher.ts
 var ConsumerBuildArtifactsPublisher = class {
 	async publish(snapshot, discoveredPlugins) {
@@ -36,10 +53,9 @@ var ConsumerBuildArtifactsPublisher = class {
 		await mkdir(path.dirname(outputPath), { recursive: true });
 		const outputLines = ["const codemationDiscoveredPlugins = [];", ""];
 		discoveredPlugins.forEach((discoveredPlugin, index) => {
-			const pluginFileUrl = pathToFileURL(path.resolve(discoveredPlugin.packageRoot, discoveredPlugin.manifest.entry)).href;
-			const exportNameAccessor = discoveredPlugin.manifest.exportName ? `pluginModule${index}[${JSON.stringify(discoveredPlugin.manifest.exportName)}]` : `pluginModule${index}.default ?? pluginModule${index}.codemationPlugin`;
+			const pluginFileUrl = pathToFileURL(path.resolve(discoveredPlugin.packageRoot, this.resolvePluginEntry(discoveredPlugin))).href;
 			outputLines.push(`const pluginModule${index} = await import(${JSON.stringify(pluginFileUrl)});`);
-			outputLines.push(`const pluginValue${index} = ${exportNameAccessor};`);
+			outputLines.push(`const pluginValue${index} = pluginModule${index}.default ?? pluginModule${index}.codemationPlugin;`);
 			outputLines.push(`if (pluginValue${index} && typeof pluginValue${index}.register === "function") {`);
 			outputLines.push(`  codemationDiscoveredPlugins.push(pluginValue${index});`);
 			outputLines.push(`} else if (typeof pluginValue${index} === "function" && pluginValue${index}.prototype && typeof pluginValue${index}.prototype.register === "function") {`);
@@ -68,45 +84,32 @@ var ConsumerBuildArtifactsPublisher = class {
 		await rename(temporaryManifestPath, snapshot.manifestPath);
 		return manifest;
 	}
-};
-
-//#endregion
-//#region src/build/ConsumerBuildOptionsParser.ts
-var ConsumerBuildOptionsParser = class {
-	parse(args) {
-		return {
-			sourceMaps: args.noSourceMaps !== true,
-			target: this.parseTarget(args.target)
-		};
-	}
-	parseTarget(raw) {
-		if (raw === void 0 || raw.trim() === "") return "es2022";
-		const normalized = raw.trim();
-		if (normalized === "es2020" || normalized === "es2022") return normalized;
-		throw new Error(`Invalid --target "${raw}". Use es2020 or es2022.`);
+	resolvePluginEntry(discoveredPlugin) {
+		if (typeof discoveredPlugin.developmentEntry === "string" && discoveredPlugin.developmentEntry.trim().length > 0) return discoveredPlugin.developmentEntry;
+		return discoveredPlugin.pluginEntry;
 	}
 };
 
 //#endregion
 //#region src/commands/BuildCommand.ts
 var BuildCommand = class {
-	constructor(cliLogger, pathResolver, pluginDiscovery, artifactsPublisher, tsRuntime, outputBuilderLoader) {
+	constructor(cliLogger, pathResolver, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, tsRuntime) {
 		this.cliLogger = cliLogger;
 		this.pathResolver = pathResolver;
+		this.consumerOutputBuilderFactory = consumerOutputBuilderFactory;
 		this.pluginDiscovery = pluginDiscovery;
-		this.artifactsPublisher = artifactsPublisher;
+		this.consumerBuildArtifactsPublisher = consumerBuildArtifactsPublisher;
 		this.tsRuntime = tsRuntime;
-		this.outputBuilderLoader = outputBuilderLoader;
 	}
 	async execute(consumerRoot, buildOptions) {
 		const paths = await this.pathResolver.resolve(consumerRoot);
 		this.tsRuntime.configure(paths.repoRoot);
-		const snapshot = await this.outputBuilderLoader.create(paths.consumerRoot, buildOptions).ensureBuilt();
+		const snapshot = await this.consumerOutputBuilderFactory.create(paths.consumerRoot, { buildOptions }).ensureBuilt();
 		const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
-		const manifest = await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
+		const manifest = await this.consumerBuildArtifactsPublisher.publish(snapshot, discoveredPlugins);
 		this.cliLogger.info(`Built consumer output: ${snapshot.outputEntryPath}`);
-		this.cliLogger.info(`Discovered plugins: ${discoveredPlugins.length}`);
-		this.cliLogger.info(`Published build: ${manifest.buildVersion}`);
+		this.cliLogger.info(`Build manifest: ${manifest.manifestPath}`);
+		this.cliLogger.info(`Workflow modules emitted: ${snapshot.workflowSourcePaths.length}`);
 	}
 };
 
@@ -125,7 +128,7 @@ var DbMigrateCommand = class {
 //#region src/commands/DevCommand.ts
 var DevCommand = class {
 	require = createRequire(import.meta.url);
-	constructor(pathResolver, tsRuntime, devLockFactory, devSourceWatcherFactory, cliLogger, session, databaseMigrationsApplyService, devBootstrapSummaryFetcher, devCliBannerRenderer, devConsumerPublishBootstrap, consumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory, devApiRuntimeFactory, cliDevProxyServerFactory, devRebuildQueueFactory) {
+	constructor(pathResolver, tsRuntime, devLockFactory, devSourceWatcherFactory, cliLogger, session, databaseMigrationsApplyService, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, devBootstrapSummaryFetcher, devCliBannerRenderer, consumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory, devApiRuntimeFactory, cliDevProxyServerFactory, devRebuildQueueFactory) {
 		this.pathResolver = pathResolver;
 		this.tsRuntime = tsRuntime;
 		this.devLockFactory = devLockFactory;
@@ -133,9 +136,11 @@ var DevCommand = class {
 		this.cliLogger = cliLogger;
 		this.session = session;
 		this.databaseMigrationsApplyService = databaseMigrationsApplyService;
+		this.consumerOutputBuilderFactory = consumerOutputBuilderFactory;
+		this.pluginDiscovery = pluginDiscovery;
+		this.consumerBuildArtifactsPublisher = consumerBuildArtifactsPublisher;
 		this.devBootstrapSummaryFetcher = devBootstrapSummaryFetcher;
 		this.devCliBannerRenderer = devCliBannerRenderer;
-		this.devConsumerPublishBootstrap = devConsumerPublishBootstrap;
 		this.consumerEnvDotenvFilePredicate = consumerEnvDotenvFilePredicate;
 		this.devTrackedProcessTreeKiller = devTrackedProcessTreeKiller;
 		this.nextHostConsumerServerCommandFactory = nextHostConsumerServerCommandFactory;
@@ -145,10 +150,11 @@ var DevCommand = class {
 	}
 	async execute(args) {
 		const paths = await this.pathResolver.resolve(args.consumerRoot);
+		const commandName = args.commandName ?? "dev";
+		const previousDevelopmentServerToken = process$1.env.CODEMATION_DEV_SERVER_TOKEN;
 		this.devCliBannerRenderer.renderBrandHeader();
 		this.tsRuntime.configure(paths.repoRoot);
-		await this.databaseMigrationsApplyService.applyForConsumer(paths.consumerRoot);
-		await this.devConsumerPublishBootstrap.ensurePublished(paths);
+		await this.databaseMigrationsApplyService.applyForConsumer(paths.consumerRoot, { configPath: args.configPathOverride });
 		const devMode = this.resolveDevMode(args);
 		const { nextPort, gatewayPort } = await this.session.sessionPorts.resolve({
 			devMode,
@@ -160,26 +166,34 @@ var DevCommand = class {
 			consumerRoot: paths.consumerRoot,
 			nextPort: devMode === "watch-framework" ? nextPort : gatewayPort
 		});
-		const authSettings = await this.session.devAuthLoader.loadForConsumer(paths.consumerRoot);
+		const authSettings = await this.session.nextHostEdgeSeedLoader.loadForConsumer(paths.consumerRoot, { configPathOverride: args.configPathOverride });
 		const watcher = this.devSourceWatcherFactory.create();
 		const processState = this.createInitialProcessState();
 		let proxyServer = null;
 		try {
-			const prepared = await this.prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings);
+			const prepared = await this.prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings, args.configPathOverride);
+			if (prepared.devMode === "packaged-ui") await this.publishConsumerArtifacts(prepared.paths, prepared.configPathOverride);
+			process$1.env.CODEMATION_DEV_SERVER_TOKEN = prepared.developmentServerToken;
 			const stopPromise = this.wireStopPromise(processState);
-			const uiProxyBase = await this.startPackagedUiWhenNeeded(prepared, processState);
+			const uiProxyBase = await this.preparePackagedUiBaseUrlWhenNeeded(prepared, processState);
 			proxyServer = await this.startProxyServer(prepared.gatewayPort, uiProxyBase);
 			const gatewayBaseUrl = this.gatewayBaseHttpUrl(gatewayPort);
 			await this.bootInitialRuntime(prepared, processState, proxyServer);
 			await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
 			const initialSummary = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
 			if (initialSummary) this.devCliBannerRenderer.renderRuntimeSummary(initialSummary);
+			await this.startPackagedUiWhenNeeded(prepared, processState, uiProxyBase);
 			this.bindShutdownSignalsToChildProcesses(processState, proxyServer);
 			await this.spawnDevUiWhenNeeded(prepared, processState, gatewayBaseUrl);
-			await this.startWatcherForSourceRestart(prepared, processState, watcher, devMode, gatewayBaseUrl, proxyServer);
-			this.logPackagedUiDevHintWhenNeeded(devMode, gatewayPort);
+			await this.startWatcherForSourceRestart(prepared, processState, watcher, devMode, gatewayBaseUrl, proxyServer, {
+				commandName,
+				configPathOverride: args.configPathOverride
+			});
+			this.logPackagedUiDevHintWhenNeeded(devMode, gatewayPort, commandName);
 			await stopPromise;
 		} finally {
+			if (previousDevelopmentServerToken === void 0) delete process$1.env.CODEMATION_DEV_SERVER_TOKEN;
+			else process$1.env.CODEMATION_DEV_SERVER_TOKEN = previousDevelopmentServerToken;
 			processState.stopRequested = true;
 			await this.stopLiveProcesses(processState, proxyServer);
 			await watcher.stop();
@@ -190,14 +204,15 @@ var DevCommand = class {
 		if (args.watchFramework === true || process$1.env.CODEMATION_DEV_MODE === "framework") return "watch-framework";
 		return "packaged-ui";
 	}
-	async prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings) {
+	async prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings, configPathOverride) {
 		return {
 			paths,
+			configPathOverride,
 			devMode,
 			nextPort,
 			gatewayPort,
 			authSettings,
-			developmentServerToken: this.session.devAuthLoader.resolveDevelopmentServerToken(process$1.env.CODEMATION_DEV_SERVER_TOKEN),
+			developmentServerToken: this.session.nextHostEdgeSeedLoader.resolveDevelopmentServerToken(process$1.env.CODEMATION_DEV_SERVER_TOKEN),
 			consumerEnv: this.session.consumerEnvLoader.load(paths.consumerRoot)
 		};
 	}
@@ -222,30 +237,30 @@ var DevCommand = class {
 	gatewayBaseHttpUrl(gatewayPort) {
 		return `http://127.0.0.1:${gatewayPort}`;
 	}
-	async startPackagedUiWhenNeeded(prepared, state) {
+	async preparePackagedUiBaseUrlWhenNeeded(prepared, state) {
 		if (prepared.devMode !== "packaged-ui") return "";
-		const websocketPort = prepared.gatewayPort;
 		const uiProxyBase = state.currentPackagedUiBaseUrl ?? `http://127.0.0.1:${await this.session.loopbackPortAllocator.allocate()}`;
 		state.currentPackagedUiBaseUrl = uiProxyBase;
-		await this.spawnPackagedUi(prepared, state, prepared.authSettings, websocketPort, uiProxyBase);
 		return uiProxyBase;
 	}
+	async startPackagedUiWhenNeeded(prepared, state, uiProxyBase) {
+		if (prepared.devMode !== "packaged-ui" || uiProxyBase.length === 0) return;
+		await this.spawnPackagedUi(prepared, state, prepared.authSettings, prepared.gatewayPort, uiProxyBase);
+	}
 	async spawnPackagedUi(prepared, state, authSettings, websocketPort, uiProxyBase) {
 		const nextHostPackageJsonPath = this.require.resolve("@codemation/next-host/package.json");
 		const nextHostRoot = path.dirname(nextHostPackageJsonPath);
 		const nextHostCommand = await this.nextHostConsumerServerCommandFactory.create({ nextHostRoot });
-		const consumerOutputManifestPath = path.resolve(prepared.paths.consumerRoot, ".codemation", "output", "current.json");
 		const uiPort = Number(new URL(uiProxyBase).port);
 		const nextHostEnvironment = this.session.nextHostEnvBuilder.buildConsumerUiProxy({
-			authConfigJson: authSettings.authConfigJson,
 			authSecret: authSettings.authSecret,
+			configPathOverride: prepared.configPathOverride,
 			consumerRoot: prepared.paths.consumerRoot,
-			consumerOutputManifestPath,
 			developmentServerToken: prepared.developmentServerToken,
 			nextPort: uiPort,
 			publicBaseUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
 			runtimeDevUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
-			skipUiAuth: authSettings.skipUiAuth,
+			skipUiAuth: !authSettings.uiAuthEnabled,
 			websocketPort
 		});
 		state.currentPackagedUi = spawn(nextHostCommand.command, nextHostCommand.args, {
@@ -319,11 +334,12 @@ var DevCommand = class {
 		const nextHostPackageJsonPath = this.require.resolve("@codemation/next-host/package.json");
 		const nextHostRoot = path.dirname(nextHostPackageJsonPath);
 		const nextHostEnvironment = this.session.nextHostEnvBuilder.build({
-			authConfigJson: authSettings.authConfigJson,
+			authSecret: authSettings.authSecret,
+			configPathOverride: prepared.configPathOverride,
 			consumerRoot: prepared.paths.consumerRoot,
 			developmentServerToken: prepared.developmentServerToken,
 			nextPort: prepared.nextPort,
-			skipUiAuth: authSettings.skipUiAuth,
+			skipUiAuth: !authSettings.uiAuthEnabled,
 			websocketPort,
 			runtimeDevUrl: gatewayBaseUrl
 		});
@@ -354,7 +370,7 @@ var DevCommand = class {
 		});
 		await this.session.devHttpProbe.waitUntilUrlRespondsOk(`http://127.0.0.1:${prepared.nextPort}/`);
 	}
-	async startWatcherForSourceRestart(prepared, state, watcher, devMode, gatewayBaseUrl, proxyServer) {
+	async startWatcherForSourceRestart(prepared, state, watcher, devMode, gatewayBaseUrl, proxyServer, options) {
 		const rebuildQueue = this.devRebuildQueueFactory.create({ run: async (request) => {
 			await this.runQueuedRebuild(prepared, state, gatewayBaseUrl, proxyServer, request);
 		} });
@@ -370,18 +386,14 @@ var DevCommand = class {
 					return;
 				}
 				try {
-					const shouldRepublishConsumerOutput = this.session.sourceChangeClassifier.shouldRepublishConsumerOutput({
-						changedPaths,
-						consumerRoot: prepared.paths.consumerRoot
-					});
 					const shouldRestartUi = this.session.sourceChangeClassifier.requiresUiRestart({
 						changedPaths,
 						consumerRoot: prepared.paths.consumerRoot
 					});
-					process$1.stdout.write(shouldRestartUi ? "\n[codemation] Source change detected — rebuilding consumer, restarting the runtime, and restarting the UI…\n" : "\n[codemation] Source change detected — rebuilding consumer and restarting the runtime…\n");
+					process$1.stdout.write(shouldRestartUi ? `\n[codemation] Source change detected — rebuilding for \`${options.commandName}\`, restarting the runtime, and restarting the UI…\n` : `\n[codemation] Source change detected — rebuilding for \`${options.commandName}\` and restarting the runtime…\n`);
 					await rebuildQueue.enqueue({
 						changedPaths,
-						shouldRepublishConsumerOutput,
+						configPathOverride: options.configPathOverride,
 						shouldRestartUi
 					});
 				} catch (error) {
@@ -395,7 +407,7 @@ var DevCommand = class {
 		proxyServer.setBuildStatus("building");
 		proxyServer.broadcastBuildStarted();
 		try {
-			if (request.shouldRepublishConsumerOutput) await this.devConsumerPublishBootstrap.ensurePublished(prepared.paths);
+			if (prepared.devMode === "packaged-ui") await this.publishConsumerArtifacts(prepared.paths, request.configPathOverride);
 			await this.stopCurrentRuntime(state, proxyServer);
 			process$1.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
 			const runtime = await this.createRuntime(prepared);
@@ -404,11 +416,11 @@ var DevCommand = class {
 				httpPort: runtime.httpPort,
 				workflowWebSocketPort: runtime.workflowWebSocketPort
 			});
-			if (request.shouldRestartUi) await this.restartUiAfterSourceChange(prepared, state, gatewayBaseUrl);
 			await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
 			const json = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
 			if (json) this.devCliBannerRenderer.renderCompact(json);
 			proxyServer.setBuildStatus("idle");
+			if (request.shouldRestartUi) await this.restartUiAfterSourceChange(prepared, state, gatewayBaseUrl);
 			proxyServer.broadcastBuildCompleted(runtime.buildVersion);
 			process$1.stdout.write("[codemation] Runtime ready.\n");
 		} catch (error) {
@@ -418,7 +430,7 @@ var DevCommand = class {
 		}
 	}
 	async restartUiAfterSourceChange(prepared, state, gatewayBaseUrl) {
-		const refreshedAuthSettings = await this.session.devAuthLoader.loadForConsumer(prepared.paths.consumerRoot);
+		const refreshedAuthSettings = await this.session.nextHostEdgeSeedLoader.loadForConsumer(prepared.paths.consumerRoot, { configPathOverride: prepared.configPathOverride });
 		process$1.stdout.write("[codemation] Restarting the UI process to apply source changes…\n");
 		state.isRestartingUi = true;
 		try {
@@ -465,6 +477,7 @@ var DevCommand = class {
 	async createRuntime(prepared) {
 		const runtimeEnvironment = this.session.consumerEnvLoader.mergeIntoProcessEnvironment(process$1.env, prepared.consumerEnv);
 		return await this.devApiRuntimeFactory.create({
+			configPathOverride: prepared.configPathOverride,
 			consumerRoot: prepared.paths.consumerRoot,
 			runtimeWorkingDirectory: process$1.cwd(),
 			env: {
@@ -477,9 +490,33 @@ var DevCommand = class {
 			}
 		});
 	}
-	logPackagedUiDevHintWhenNeeded(devMode, gatewayPort) {
+	async publishConsumerArtifacts(paths, configPathOverride) {
+		const snapshot = await this.consumerOutputBuilderFactory.create(paths.consumerRoot, { configPathOverride }).ensureBuilt();
+		const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
+		await this.consumerBuildArtifactsPublisher.publish(snapshot, discoveredPlugins);
+		this.cliLogger.debug(`Dev: consumer output published (${snapshot.buildVersion}).`);
+	}
+	logPackagedUiDevHintWhenNeeded(devMode, gatewayPort, commandName) {
 		if (devMode !== "packaged-ui") return;
-		this.cliLogger.info(`codemation dev: open http://127.0.0.1:${gatewayPort} — this uses the packaged @codemation/next-host UI. Use \`codemation dev --watch-framework\` only when working on the framework UI itself.`);
+		this.cliLogger.info(`codemation ${commandName}: open http://127.0.0.1:${gatewayPort} — this uses the packaged @codemation/next-host UI. Use \`codemation ${commandName} --watch-framework\` only when working on the framework UI itself.`);
+	}
+};
+
+//#endregion
+//#region src/commands/DevPluginCommand.ts
+var DevPluginCommand = class {
+	constructor(pluginDevConfigFactory, devCommand) {
+		this.pluginDevConfigFactory = pluginDevConfigFactory;
+		this.devCommand = devCommand;
+	}
+	async execute(args) {
+		const pluginConfig = await this.pluginDevConfigFactory.prepare(args.pluginRoot);
+		await this.devCommand.execute({
+			commandName: "dev:plugin",
+			configPathOverride: pluginConfig.configPath,
+			consumerRoot: args.pluginRoot,
+			watchFramework: args.watchFramework
+		});
 	}
 };
 
@@ -487,38 +524,22 @@ var DevCommand = class {
 //#region src/commands/ServeWebCommand.ts
 var ServeWebCommand = class {
 	require = createRequire(import.meta.url);
-	constructor(pathResolver, configLoader, pluginDiscovery, artifactsPublisher, tsRuntime, sourceMapNodeOptions, outputBuilderLoader, envLoader, listenPortResolver, nextHostConsumerServerCommandFactory, frontendAuthSnapshotFactory, frontendAppConfigJsonCodec) {
+	constructor(pathResolver, configLoader, tsRuntime, sourceMapNodeOptions, envLoader, listenPortResolver, nextHostConsumerServerCommandFactory) {
 		this.pathResolver = pathResolver;
 		this.configLoader = configLoader;
-		this.pluginDiscovery = pluginDiscovery;
-		this.artifactsPublisher = artifactsPublisher;
 		this.tsRuntime = tsRuntime;
 		this.sourceMapNodeOptions = sourceMapNodeOptions;
-		this.outputBuilderLoader = outputBuilderLoader;
 		this.envLoader = envLoader;
 		this.listenPortResolver = listenPortResolver;
 		this.nextHostConsumerServerCommandFactory = nextHostConsumerServerCommandFactory;
-		this.frontendAuthSnapshotFactory = frontendAuthSnapshotFactory;
-		this.frontendAppConfigJsonCodec = frontendAppConfigJsonCodec;
 	}
 	async execute(consumerRoot, buildOptions) {
 		const paths = await this.pathResolver.resolve(consumerRoot);
 		this.tsRuntime.configure(paths.repoRoot);
-		const snapshot = await this.outputBuilderLoader.create(paths.consumerRoot, buildOptions).ensureBuilt();
-		const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
-		const manifest = await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
 		const nextHostRoot = path.dirname(this.require.resolve("@codemation/next-host/package.json"));
 		const nextHostCommand = await this.nextHostConsumerServerCommandFactory.create({ nextHostRoot });
 		const consumerEnv = this.envLoader.load(paths.consumerRoot);
 		const configResolution = await this.configLoader.load({ consumerRoot: paths.consumerRoot });
-		const frontendAuthSnapshot = this.frontendAuthSnapshotFactory.createFromResolvedInputs({
-			authConfig: configResolution.config.auth,
-			env: {
-				...process$1.env,
-				...consumerEnv
-			},
-			uiAuthEnabled: !(consumerEnv.NODE_ENV !== "production" && configResolution.config.auth?.allowUnauthenticatedInDevelopment === true)
-		});
 		const nextPort = this.listenPortResolver.resolvePrimaryApplicationPort(process$1.env.PORT);
 		const websocketPort = this.listenPortResolver.resolveWebsocketPortRelativeToHttp({
 			nextPort,
@@ -532,13 +553,8 @@ var ServeWebCommand = class {
 				...process$1.env,
 				...consumerEnv,
 				PORT: String(nextPort),
-				CODEMATION_FRONTEND_APP_CONFIG_JSON: this.frontendAppConfigJsonCodec.serialize({
-					auth: frontendAuthSnapshot,
-					productName: "Codemation",
-					logoUrl: null
-				}),
-				CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: manifest.manifestPath,
 				CODEMATION_CONSUMER_ROOT: paths.consumerRoot,
+				CODEMATION_UI_AUTH_ENABLED: String(!(consumerEnv.NODE_ENV !== "production" && configResolution.config.auth?.allowUnauthenticatedInDevelopment === true)),
 				CODEMATION_WS_PORT: String(websocketPort),
 				NEXT_PUBLIC_CODEMATION_WS_PORT: String(websocketPort),
 				NODE_OPTIONS: this.sourceMapNodeOptions.appendToNodeOptions(process$1.env.NODE_OPTIONS),
@@ -765,8 +781,9 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 	lastIssuedBuildVersion = 0;
 	log;
 	buildOptions;
-	constructor(consumerRoot, logOverride, buildOptionsOverride) {
+	constructor(consumerRoot, logOverride, buildOptionsOverride, configPathOverride) {
 		this.consumerRoot = consumerRoot;
+		this.configPathOverride = configPathOverride;
 		this.log = logOverride ?? defaultConsumerOutputLogger;
 		this.buildOptions = buildOptionsOverride ?? defaultConsumerBuildOptions;
 	}
@@ -978,6 +995,7 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 						sourcePath
 					});
 				}
+				await this.emitConfigSourceFile(outputAppRoot, configSourcePath, runtimeSourcePaths);
 			}
 		});
 	}
@@ -1036,6 +1054,14 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 		await writeFile(outputPath, rewrittenOutputText, "utf8");
 		if (transpiledOutput.sourceMapText) await writeFile(`${outputPath}.map`, transpiledOutput.sourceMapText, "utf8");
 	}
+	async emitConfigSourceFile(outputAppRoot, configSourcePath, runtimeSourcePaths) {
+		const normalizedConfigSourcePath = path.resolve(configSourcePath);
+		if (runtimeSourcePaths.some((sourcePath) => path.resolve(sourcePath) === normalizedConfigSourcePath)) return;
+		await this.emitSourceFile({
+			outputAppRoot,
+			sourcePath: normalizedConfigSourcePath
+		});
+	}
 	createCompilerOptions() {
 		const scriptTarget = this.buildOptions.target === "es2020" ? ts.ScriptTarget.ES2020 : ts.ScriptTarget.ES2022;
 		return {
@@ -1176,6 +1202,12 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 		return `${nextBuildVersion}-${process$1.pid}`;
 	}
 	async resolveConfigPath(consumerRoot) {
+		const configuredOverride = this.configPathOverride?.trim();
+		if (configuredOverride && configuredOverride.length > 0) {
+			const resolvedOverride = path.resolve(configuredOverride);
+			if (await this.fileExists(resolvedOverride)) return resolvedOverride;
+			throw new Error(`Codemation config override not found at ${resolvedOverride}.`);
+		}
 		for (const candidate of this.getConventionCandidates(consumerRoot)) if (await this.fileExists(candidate)) return candidate;
 		return null;
 	}
@@ -1289,10 +1321,10 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 };
 
 //#endregion
-//#region src/consumer/Loader.ts
-var ConsumerOutputBuilderLoader = class {
-	create(consumerRoot, buildOptions) {
-		return new ConsumerOutputBuilder(consumerRoot, void 0, buildOptions);
+//#region src/consumer/ConsumerOutputBuilderFactory.ts
+var ConsumerOutputBuilderFactory = class {
+	create(consumerRoot, args) {
+		return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions, args?.configPathOverride);
 	}
 };
 
@@ -1464,8 +1496,9 @@ var DevCliBannerRenderer = class {
 			title: chalk.bold("Runtime"),
 			titleAlignment: "center"
 		});
+		const pluginsSection = this.buildPluginsSection(summary);
 		const activeSection = this.buildActiveWorkflowsSection(summary);
-		process.stdout.write(`${detailBox}\n${activeSection}\n`);
+		process.stdout.write(`${detailBox}\n${pluginsSection}\n${activeSection}\n`);
 	}
 	renderFull(summary) {
 		this.renderBrandHeader();
@@ -1492,8 +1525,9 @@ var DevCliBannerRenderer = class {
 			title: chalk.bold("Runtime (updated)"),
 			titleAlignment: "center"
 		});
+		const pluginsSection = this.buildPluginsSection(summary);
 		const activeSection = this.buildActiveWorkflowsSection(summary);
-		process.stdout.write(`\n${detailBox}\n${activeSection}\n`);
+		process.stdout.write(`\n${detailBox}\n${pluginsSection}\n${activeSection}\n`);
 	}
 	renderFigletTitle() {
 		try {
@@ -1532,28 +1566,23 @@ var DevCliBannerRenderer = class {
 			titleAlignment: "left"
 		});
 	}
-};
-
-//#endregion
-//#region src/dev/DevConsumerPublishBootstrap.ts
-/**
-* Ensures `.codemation/output/current.json` and transpiled consumer config exist before the Next host boots.
-* Without this, `codemation dev` can serve a stale built `codemation.config.js` (e.g. missing whitelabel).
-*/
-var DevConsumerPublishBootstrap = class {
-	constructor(cliLogger, pluginDiscovery, artifactsPublisher, outputBuilderLoader, buildOptionsParser) {
-		this.cliLogger = cliLogger;
-		this.pluginDiscovery = pluginDiscovery;
-		this.artifactsPublisher = artifactsPublisher;
-		this.outputBuilderLoader = outputBuilderLoader;
-		this.buildOptionsParser = buildOptionsParser;
-	}
-	async ensurePublished(paths) {
-		const buildOptions = this.buildOptionsParser.parse({});
-		const snapshot = await this.outputBuilderLoader.create(paths.consumerRoot, buildOptions).ensureBuilt();
-		const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
-		await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
-		this.cliLogger.debug(`Dev: consumer output published (${snapshot.buildVersion}).`);
+	buildPluginsSection(summary) {
+		return boxen((summary.plugins.length === 0 ? [chalk.dim("  (none discovered or configured)")] : summary.plugins.map((plugin) => `${chalk.whiteBright(`  • ${plugin.packageName} `)}${chalk.dim(`(${plugin.source})`)}`)).join("\n"), {
+			padding: {
+				top: 0,
+				bottom: 0,
+				left: 0,
+				right: 0
+			},
+			margin: {
+				top: 1,
+				bottom: 0
+			},
+			borderStyle: "single",
+			borderColor: "cyan",
+			title: chalk.bold("Plugins"),
+			titleAlignment: "left"
+		});
 	}
 };
 
@@ -1746,12 +1775,27 @@ var CliDevProxyServer = class {
 			return url.split("?")[0] ?? url;
 		}
 	}
+	extractOccupyingPids(listenerDescription) {
+		const seen = /* @__PURE__ */ new Set();
+		const re = /pid=(\d+)/g;
+		let match;
+		while ((match = re.exec(listenerDescription)) !== null) {
+			const pid = Number.parseInt(match[1] ?? "0", 10);
+			if (Number.isFinite(pid) && pid > 0) seen.add(pid);
+		}
+		return [...seen];
+	}
 	async rejectListenError(error, reject) {
 		if (error.code !== "EADDRINUSE") {
 			reject(error);
 			return;
 		}
 		const description = await this.listenPortConflictDescriber.describeLoopbackPort(this.listenPort);
+		const occupyingPids = description !== null ? this.extractOccupyingPids(description) : [];
+		if (occupyingPids.length > 0) {
+			const pidList = occupyingPids.join(", ");
+			process.stderr.write(`[codemation] Dev gateway port ${this.listenPort} is already in use (occupying pid(s): ${pidList}).\n`);
+		}
 		const baseMessage = `Dev gateway port ${this.listenPort} is already in use on 127.0.0.1.`;
 		const suffix = description === null ? " Stop the process using that port or change the configured Codemation dev port." : ` Listener: ${description}. Stop that process or change the configured Codemation dev port.`;
 		reject(new Error(`${baseMessage}${suffix}`, { cause: error instanceof Error ? error : void 0 }));
@@ -1929,12 +1973,19 @@ var ListenPortConflictDescriber = class {
 	async describeLoopbackPort(port) {
 		if (!Number.isInteger(port) || port <= 0) return null;
 		if (this.platform !== "linux" && this.platform !== "darwin") return null;
-		const raw = await this.readLsofOutput(port);
-		if (raw === null) return null;
-		const occupants = this.parseLsofOutput(raw);
+		const occupants = await this.resolveLoopbackOccupants(port);
 		if (occupants.length === 0) return null;
 		return occupants.map((occupant) => `pid=${occupant.pid} command=${occupant.command} endpoint=${occupant.endpoint}`).join("; ");
 	}
+	async resolveLoopbackOccupants(port) {
+		const lsofRaw = await this.readLsofOutput(port);
+		const fromLsof = lsofRaw !== null ? this.parseLsofOutput(lsofRaw) : [];
+		if (fromLsof.length > 0) return fromLsof;
+		if (this.platform !== "linux") return [];
+		const ssRaw = await this.readSsOutput(port);
+		if (ssRaw === null) return [];
+		return this.parseSsListenOutput(ssRaw, port);
+	}
 	async readLsofOutput(port) {
 		try {
 			return await new Promise((resolve, reject) => {
@@ -1980,6 +2031,44 @@ var ListenPortConflictDescriber = class {
 		}
 		return occupants;
 	}
+	async readSsOutput(port) {
+		const filtered = await this.execFileStdout("ss", ["-lntp", `sport = :${port}`]);
+		if (filtered !== null && filtered.trim().length > 0) return filtered;
+		return this.execFileStdout("ss", ["-lntp"]);
+	}
+	async execFileStdout(command, args) {
+		try {
+			return await new Promise((resolve, reject) => {
+				execFile(command, [...args], (error, stdout) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve(stdout);
+				});
+			});
+		} catch {
+			return null;
+		}
+	}
+	parseSsListenOutput(raw, port) {
+		const occupants = [];
+		const portSuffix = `:${port}`;
+		for (const line of raw.split("\n")) {
+			if (!line.includes("LISTEN") || !line.includes(portSuffix)) continue;
+			const pidMatch = line.match(/pid=(\d+)/);
+			if (!pidMatch) continue;
+			const pid = Number.parseInt(pidMatch[1] ?? "0", 10);
+			const command = line.match(/users:\(\("([^"]*)"/)?.[1] ?? "unknown";
+			const endpoint = line.match(/\s+(\S+:\d+|\[[^\]]+\]:\d+)\s+/)?.[1] ?? `tcp:${String(port)}`;
+			occupants.push({
+				pid,
+				command,
+				endpoint
+			});
+		}
+		return occupants;
+	}
 };
 
 //#endregion
@@ -2089,7 +2178,8 @@ var CodemationTsyringeTypeInfoRegistrar = class {
 //#endregion
 //#region src/dev/DevApiRuntimeHost.ts
 var DevApiRuntimeHost = class {
-	pluginListMerger = new CodemationPluginListMerger();
+	pluginPackageMetadata = new CodemationPluginPackageMetadata();
+	pluginListMerger = new CodemationPluginListMerger(this.pluginPackageMetadata);
 	contextPromise = null;
 	constructor(configLoader, pluginDiscovery, args) {
 		this.configLoader = configLoader;
@@ -2118,14 +2208,17 @@ var DevApiRuntimeHost = class {
 		env.CODEMATION_CONSUMER_ROOT = consumerRoot;
 		const configResolution = await this.configLoader.load({
 			consumerRoot,
+			configPathOverride: this.args.configPathOverride,
 			repoRoot,
 			env
 		});
 		const discoveredPlugins = await this.loadDiscoveredPlugins(consumerRoot);
+		const mergedPlugins = discoveredPlugins.length > 0 ? this.pluginListMerger.merge(configResolution.appConfig.plugins, discoveredPlugins) : configResolution.appConfig.plugins;
 		const appConfig = {
 			...configResolution.appConfig,
 			env,
-			plugins: discoveredPlugins.length > 0 ? this.pluginListMerger.merge(configResolution.appConfig.plugins, discoveredPlugins) : configResolution.appConfig.plugins
+			plugins: mergedPlugins,
+			pluginLoadSummary: this.createPluginLoadSummary(configResolution.appConfig.plugins, discoveredPlugins, mergedPlugins)
 		};
 		const container = await new AppContainerFactory$1().create({
 			appConfig,
@@ -2145,6 +2238,20 @@ var DevApiRuntimeHost = class {
 	async loadDiscoveredPlugins(consumerRoot) {
 		return (await this.pluginDiscovery.resolvePlugins(consumerRoot)).map((resolvedPackage) => resolvedPackage.plugin);
 	}
+	createPluginLoadSummary(configuredPlugins, discoveredPlugins, mergedPlugins) {
+		const configuredPluginSet = new Set(configuredPlugins);
+		const discoveredPluginSet = new Set(discoveredPlugins);
+		const summaries = [];
+		for (const plugin of mergedPlugins) {
+			const packageName = this.pluginPackageMetadata.readPackageName(plugin);
+			if (!packageName) continue;
+			summaries.push({
+				packageName,
+				source: configuredPluginSet.has(plugin) || !discoveredPluginSet.has(plugin) ? "configured" : "discovered"
+			});
+		}
+		return summaries;
+	}
 	async detectWorkspaceRoot(startDirectory) {
 		let currentDirectory = path.resolve(startDirectory);
 		while (true) {
@@ -2262,6 +2369,7 @@ var DevApiRuntimeFactory = class {
 		const httpPort = await this.portAllocator.allocate();
 		const workflowWebSocketPort = await this.portAllocator.allocate();
 		const runtime = new DevApiRuntimeServer(httpPort, workflowWebSocketPort, new DevApiRuntimeHost(this.configLoader, this.pluginDiscovery, {
+			configPathOverride: args.configPathOverride,
 			consumerRoot: args.consumerRoot,
 			env: {
 				...args.env,
@@ -2318,7 +2426,7 @@ var DevRebuildQueue = class {
 		};
 		return {
 			changedPaths: [...new Set([...current.changedPaths, ...next.changedPaths])],
-			shouldRepublishConsumerOutput: current.shouldRepublishConsumerOutput || next.shouldRepublishConsumerOutput,
+			configPathOverride: next.configPathOverride ?? current.configPathOverride,
 			shouldRestartUi: current.shouldRestartUi || next.shouldRestartUi
 		};
 	}
@@ -2366,34 +2474,6 @@ var SourceMapNodeOptions = class {
 	}
 };
 
-//#endregion
-//#region src/dev/DevAuthSettingsLoader.ts
-var DevAuthSettingsLoader = class DevAuthSettingsLoader {
-	static defaultDevelopmentAuthSecret = "codemation-dev-auth-secret-not-for-production";
-	constructor(configLoader, consumerEnvLoader) {
-		this.configLoader = configLoader;
-		this.consumerEnvLoader = consumerEnvLoader;
-	}
-	resolveDevelopmentServerToken(rawToken) {
-		if (rawToken && rawToken.trim().length > 0) return rawToken;
-		return randomUUID();
-	}
-	async loadForConsumer(consumerRoot) {
-		const resolution = await this.configLoader.load({ consumerRoot });
-		const envForAuthSecret = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(consumerRoot, process.env);
-		return {
-			authConfigJson: JSON.stringify(resolution.config.auth ?? null),
-			authSecret: this.resolveDevelopmentAuthSecret(envForAuthSecret),
-			skipUiAuth: resolution.config.auth?.allowUnauthenticatedInDevelopment === true
-		};
-	}
-	resolveDevelopmentAuthSecret(env) {
-		const configuredSecret = env.AUTH_SECRET;
-		if (configuredSecret && configuredSecret.trim().length > 0) return configuredSecret;
-		return DevAuthSettingsLoader.defaultDevelopmentAuthSecret;
-	}
-};
-
 //#endregion
 //#region src/dev/DevHttpProbe.ts
 var DevHttpProbe = class {
@@ -2438,52 +2518,41 @@ var DevHttpProbe = class {
 //#endregion
 //#region src/dev/DevNextHostEnvironmentBuilder.ts
 var DevNextHostEnvironmentBuilder = class {
-	constructor(consumerEnvLoader, sourceMapNodeOptions, frontendAuthSnapshotFactory = new CodemationFrontendAuthSnapshotFactory$1(), frontendAppConfigJsonCodec = new FrontendAppConfigJsonCodec$1()) {
+	constructor(consumerEnvLoader, sourceMapNodeOptions) {
 		this.consumerEnvLoader = consumerEnvLoader;
 		this.sourceMapNodeOptions = sourceMapNodeOptions;
-		this.frontendAuthSnapshotFactory = frontendAuthSnapshotFactory;
-		this.frontendAppConfigJsonCodec = frontendAppConfigJsonCodec;
 	}
 	buildConsumerUiProxy(args) {
+		const publicWebsocketPort = this.resolvePublicWebsocketPort(args.publicBaseUrl, args.websocketPort);
 		return {
 			...this.build({
-				authConfigJson: args.authConfigJson,
 				authSecret: args.authSecret,
+				configPathOverride: args.configPathOverride,
+				consumerOutputManifestPath: args.consumerOutputManifestPath,
 				consumerRoot: args.consumerRoot,
 				developmentServerToken: args.developmentServerToken,
 				nextPort: args.nextPort,
 				runtimeDevUrl: args.runtimeDevUrl,
 				skipUiAuth: args.skipUiAuth,
-				websocketPort: args.websocketPort,
-				consumerOutputManifestPath: args.consumerOutputManifestPath
+				websocketPort: args.websocketPort
 			}),
 			HOSTNAME: "127.0.0.1",
 			AUTH_SECRET: args.authSecret,
-			AUTH_URL: args.publicBaseUrl
+			AUTH_URL: args.publicBaseUrl,
+			CODEMATION_PUBLIC_WS_PORT: String(publicWebsocketPort),
+			NEXT_PUBLIC_CODEMATION_WS_PORT: String(publicWebsocketPort)
 		};
 	}
 	build(args) {
 		const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process$1.env);
-		const manifestPath = args.consumerOutputManifestPath ?? path.resolve(args.consumerRoot, ".codemation", "output", "current.json");
-		const authSecret = args.authSecret ?? merged.AUTH_SECRET;
-		const authSnapshot = this.frontendAuthSnapshotFactory.createFromResolvedInputs({
-			authConfig: this.parseAuthConfig(args.authConfigJson),
-			env: {
-				...merged,
-				...typeof authSecret === "string" && authSecret.trim().length > 0 ? { AUTH_SECRET: authSecret } : {}
-			},
-			uiAuthEnabled: !args.skipUiAuth
-		});
+		const consumerOutputManifestPath = args.consumerOutputManifestPath ?? path.resolve(args.consumerRoot, ".codemation", "output", "current.json");
 		return {
 			...merged,
 			PORT: String(args.nextPort),
 			CODEMATION_CONSUMER_ROOT: args.consumerRoot,
-			CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: manifestPath,
-			CODEMATION_FRONTEND_APP_CONFIG_JSON: this.frontendAppConfigJsonCodec.serialize({
-				auth: authSnapshot,
-				productName: "Codemation",
-				logoUrl: null
-			}),
+			CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: consumerOutputManifestPath,
+			CODEMATION_UI_AUTH_ENABLED: String(!args.skipUiAuth),
+			CODEMATION_PUBLIC_WS_PORT: String(args.websocketPort),
 			CODEMATION_WS_PORT: String(args.websocketPort),
 			NEXT_PUBLIC_CODEMATION_WS_PORT: String(args.websocketPort),
 			CODEMATION_DEV_SERVER_TOKEN: args.developmentServerToken,
@@ -2491,12 +2560,18 @@ var DevNextHostEnvironmentBuilder = class {
 			NODE_OPTIONS: this.sourceMapNodeOptions.appendToNodeOptions(process$1.env.NODE_OPTIONS),
 			WS_NO_BUFFER_UTIL: "1",
 			WS_NO_UTF_8_VALIDATE: "1",
+			...args.authSecret && args.authSecret.trim().length > 0 ? { AUTH_SECRET: args.authSecret.trim() } : {},
+			...args.configPathOverride && args.configPathOverride.trim().length > 0 ? { CODEMATION_CONFIG_PATH: args.configPathOverride } : {},
 			...args.runtimeDevUrl !== void 0 && args.runtimeDevUrl.trim().length > 0 ? { CODEMATION_RUNTIME_DEV_URL: args.runtimeDevUrl.trim() } : {}
 		};
 	}
-	parseAuthConfig(authConfigJson) {
-		if (authConfigJson.trim().length === 0) return;
-		return JSON.parse(authConfigJson) ?? void 0;
+	resolvePublicWebsocketPort(publicBaseUrl, fallbackPort) {
+		try {
+			const parsedUrl = new URL(publicBaseUrl);
+			const parsedPort = Number(parsedUrl.port);
+			if (Number.isInteger(parsedPort) && parsedPort > 0) return parsedPort;
+		} catch {}
+		return fallbackPort;
 	}
 };
 
@@ -2522,13 +2597,13 @@ var DevSessionPortsResolver = class {
 * Bundles dependencies for {@link DevCommand} so the command stays a thin orchestrator.
 */
 var DevSessionServices = class {
-	constructor(consumerEnvLoader, sourceMapNodeOptions, sessionPorts, loopbackPortAllocator, devHttpProbe, devAuthLoader, nextHostEnvBuilder, watchRootsResolver, sourceChangeClassifier) {
+	constructor(consumerEnvLoader, sourceMapNodeOptions, sessionPorts, loopbackPortAllocator, devHttpProbe, nextHostEdgeSeedLoader, nextHostEnvBuilder, watchRootsResolver, sourceChangeClassifier) {
 		this.consumerEnvLoader = consumerEnvLoader;
 		this.sourceMapNodeOptions = sourceMapNodeOptions;
 		this.sessionPorts = sessionPorts;
 		this.loopbackPortAllocator = loopbackPortAllocator;
 		this.devHttpProbe = devHttpProbe;
-		this.devAuthLoader = devAuthLoader;
+		this.nextHostEdgeSeedLoader = nextHostEdgeSeedLoader;
 		this.nextHostEnvBuilder = nextHostEnvBuilder;
 		this.watchRootsResolver = watchRootsResolver;
 		this.sourceChangeClassifier = sourceChangeClassifier;
@@ -2538,15 +2613,16 @@ var DevSessionServices = class {
 //#endregion
 //#region src/dev/DevSourceChangeClassifier.ts
 var DevSourceChangeClassifier = class DevSourceChangeClassifier {
-	static configFileNames = new Set([
+	static uiConfigFileNames = new Set([
 		"codemation.config.ts",
 		"codemation.config.js",
 		"codemation.config.mjs"
 	]);
-	shouldRepublishConsumerOutput(args) {
-		const resolvedConsumerRoot = path.resolve(args.consumerRoot);
-		return args.changedPaths.some((changedPath) => this.isPathInsideDirectory(changedPath, resolvedConsumerRoot));
-	}
+	static pluginConfigFileNames = new Set([
+		"codemation.plugin.ts",
+		"codemation.plugin.js",
+		"codemation.plugin.mjs"
+	]);
 	requiresUiRestart(args) {
 		const resolvedConsumerRoot = path.resolve(args.consumerRoot);
 		return args.changedPaths.some((changedPath) => this.pathRequiresUiRestart(path.resolve(changedPath), resolvedConsumerRoot));
@@ -2559,7 +2635,9 @@ var DevSourceChangeClassifier = class DevSourceChangeClassifier {
 	pathRequiresUiRestart(resolvedPath, consumerRoot) {
 		if (!this.isPathInsideDirectory(resolvedPath, consumerRoot)) return false;
 		const relativePath = path.relative(consumerRoot, resolvedPath);
-		if (DevSourceChangeClassifier.configFileNames.has(path.basename(relativePath))) return true;
+		const fileName = path.basename(relativePath);
+		if (DevSourceChangeClassifier.uiConfigFileNames.has(fileName)) return true;
+		if (DevSourceChangeClassifier.pluginConfigFileNames.has(fileName)) return false;
 		if (relativePath.startsWith(path.join("src", "workflows"))) return false;
 		if (relativePath.startsWith(path.join("src", "plugins"))) return false;
 		if (relativePath.includes("credential")) return true;
@@ -2588,6 +2666,36 @@ var LoopbackPortAllocator = class {
 	}
 };
 
+//#endregion
+//#region src/dev/NextHostEdgeSeedLoader.ts
+var NextHostEdgeSeedLoader = class NextHostEdgeSeedLoader {
+	static defaultDevelopmentAuthSecret = "codemation-dev-auth-secret-not-for-production";
+	constructor(configLoader, consumerEnvLoader) {
+		this.configLoader = configLoader;
+		this.consumerEnvLoader = consumerEnvLoader;
+	}
+	resolveDevelopmentServerToken(rawToken) {
+		if (rawToken && rawToken.trim().length > 0) return rawToken;
+		return randomUUID();
+	}
+	async loadForConsumer(consumerRoot, options) {
+		const resolution = await this.configLoader.load({
+			consumerRoot,
+			configPathOverride: options?.configPathOverride
+		});
+		const envForAuthSecret = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(consumerRoot, process.env);
+		return {
+			authSecret: this.resolveDevelopmentAuthSecret(envForAuthSecret),
+			uiAuthEnabled: resolution.config.auth?.allowUnauthenticatedInDevelopment !== true
+		};
+	}
+	resolveDevelopmentAuthSecret(env) {
+		const configuredSecret = env.AUTH_SECRET;
+		if (configuredSecret && configuredSecret.trim().length > 0) return configuredSecret;
+		return NextHostEdgeSeedLoader.defaultDevelopmentAuthSecret;
+	}
+};
+
 //#endregion
 //#region src/dev/WatchRootsResolver.ts
 var WatchRootsResolver = class {
@@ -2614,7 +2722,57 @@ var DevSessionServicesBuilder = class {
 		const sourceMapNodeOptions = new SourceMapNodeOptions();
 		const listenPortResolver = new ListenPortResolver();
 		const loopbackPortAllocator = new LoopbackPortAllocator();
-		return new DevSessionServices(consumerEnvLoader, sourceMapNodeOptions, new DevSessionPortsResolver(listenPortResolver, loopbackPortAllocator), loopbackPortAllocator, new DevHttpProbe(), new DevAuthSettingsLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader), new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions), new WatchRootsResolver(), new DevSourceChangeClassifier());
+		return new DevSessionServices(consumerEnvLoader, sourceMapNodeOptions, new DevSessionPortsResolver(listenPortResolver, loopbackPortAllocator), loopbackPortAllocator, new DevHttpProbe(), new NextHostEdgeSeedLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader), new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions), new WatchRootsResolver(), new DevSourceChangeClassifier());
+	}
+};
+
+//#endregion
+//#region src/dev/PluginDevConfigFactory.ts
+var PluginDevConfigFactory = class {
+	async prepare(pluginRoot) {
+		const pluginEntryPath = await this.resolvePluginEntryPath(pluginRoot);
+		const configPath = path.resolve(pluginRoot, ".codemation", "plugin-dev", "codemation.config.ts");
+		await mkdir(path.dirname(configPath), { recursive: true });
+		await writeFile(configPath, this.createConfigSource(configPath, pluginEntryPath), "utf8");
+		return { configPath };
+	}
+	async resolvePluginEntryPath(pluginRoot) {
+		const candidates = [
+			path.resolve(pluginRoot, "codemation.plugin.ts"),
+			path.resolve(pluginRoot, "codemation.plugin.js"),
+			path.resolve(pluginRoot, "src", "codemation.plugin.ts"),
+			path.resolve(pluginRoot, "src", "codemation.plugin.js")
+		];
+		for (const candidate of candidates) if (await this.exists(candidate)) return candidate;
+		throw new Error("Plugin config not found. Expected \"codemation.plugin.ts\" in the plugin root or \"src/\".");
+	}
+	createConfigSource(configPath, pluginEntryPath) {
+		const relativeImportPath = this.toRelativeImportPath(configPath, pluginEntryPath);
+		return [
+			"import type { CodemationConfig } from \"@codemation/host\";",
+			`import plugin from ${JSON.stringify(relativeImportPath)};`,
+			"",
+			"const sandbox = plugin.sandbox ?? {};",
+			"const config: CodemationConfig = {",
+			"  ...sandbox,",
+			"  plugins: [...(sandbox.plugins ?? []), plugin],",
+			"};",
+			"",
+			"export default config;",
+			""
+		].join("\n");
+	}
+	toRelativeImportPath(fromPath, targetPath) {
+		const relativePath = path.relative(path.dirname(fromPath), targetPath).replace(/\\/g, "/");
+		return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+	}
+	async exists(filePath) {
+		try {
+			await access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
 	}
 };
 
@@ -2870,10 +3028,11 @@ var DevSourceWatcherFactory = class {
 //#endregion
 //#region src/Program.ts
 var CliProgram = class {
-	constructor(buildOptionsParser, buildCommand, devCommand, serveWebCommand, serveWorkerCommand, dbMigrateCommand, userCreateCommand, userListCommand) {
+	constructor(buildOptionsParser, buildCommand, devCommand, devPluginCommand, serveWebCommand, serveWorkerCommand, dbMigrateCommand, userCreateCommand, userListCommand) {
 		this.buildOptionsParser = buildOptionsParser;
 		this.buildCommand = buildCommand;
 		this.devCommand = devCommand;
+		this.devPluginCommand = devPluginCommand;
 		this.serveWebCommand = serveWebCommand;
 		this.serveWorkerCommand = serveWorkerCommand;
 		this.dbMigrateCommand = dbMigrateCommand;
@@ -2893,6 +3052,9 @@ var CliProgram = class {
 				watchFramework: opts.watchFramework === true
 			});
 		});
+		program.command("dev:plugin").description("Start plugin sandbox development using `codemation.plugin.ts`.").option("--plugin-root <path>", "Path to the plugin project root (defaults to cwd)").action(async (opts) => {
+			await this.devPluginCommand.execute({ pluginRoot: resolveConsumerRoot(opts.pluginRoot) });
+		});
 		const serve$1 = program.command("serve").description("Run production web or worker processes (no dev watchers).");
 		serve$1.command("web").description("Start the packaged Codemation web host.").option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)").option("--no-source-maps", "Disable .js.map files for emitted workflow modules when this command runs the consumer build step.").option("--target <es2020|es2022>", "ECMAScript language version for emitted workflow JavaScript when building consumer output (default: es2022).", "es2022").action(async (opts) => {
 			await this.serveWebCommand.execute(resolveConsumerRoot(opts.consumerRoot), this.buildOptionsParser.parse(opts));
@@ -3160,9 +3322,7 @@ var CliProgramFactory = class {
 		const appConfigLoader = new AppConfigLoader();
 		const pathResolver = new CliPathResolver();
 		const pluginDiscovery = new CodemationPluginDiscovery();
-		const artifactsPublisher = new ConsumerBuildArtifactsPublisher();
 		const tsRuntime = new TypeScriptRuntimeConfigurator();
-		const outputBuilderLoader = new ConsumerOutputBuilderLoader();
 		const sourceMapNodeOptions = new SourceMapNodeOptions();
 		const nextHostConsumerServerCommandFactory = new NextHostConsumerServerCommandFactory();
 		const devSessionServices = new DevSessionServicesBuilder().build();
@@ -3172,8 +3332,10 @@ var CliProgramFactory = class {
 		const userAdminCliOptionsParser = new UserAdminCliOptionsParser();
 		const databaseMigrationsApplyService = new DatabaseMigrationsApplyService(cliLogger, new UserAdminConsumerDotenvLoader(), tsconfigPreparation, new CodemationConsumerConfigLoader(), new ConsumerDatabaseConnectionResolver(), new CliDatabaseUrlDescriptor(), hostPackageRoot, new PrismaMigrationDeployer());
 		const buildOptionsParser = new ConsumerBuildOptionsParser();
-		const devConsumerPublishBootstrap = new DevConsumerPublishBootstrap(cliLogger, pluginDiscovery, artifactsPublisher, outputBuilderLoader, buildOptionsParser);
-		return new CliProgram(buildOptionsParser, new BuildCommand(cliLogger, pathResolver, pluginDiscovery, artifactsPublisher, tsRuntime, outputBuilderLoader), new DevCommand(pathResolver, tsRuntime, new DevLockFactory(), new DevSourceWatcherFactory(), cliLogger, devSessionServices, databaseMigrationsApplyService, new DevBootstrapSummaryFetcher(), new DevCliBannerRenderer(), devConsumerPublishBootstrap, new ConsumerEnvDotenvFilePredicate(), new DevTrackedProcessTreeKiller(), nextHostConsumerServerCommandFactory, new DevApiRuntimeFactory(devSessionServices.loopbackPortAllocator, appConfigLoader, pluginDiscovery), new CliDevProxyServerFactory(), new DevRebuildQueueFactory()), new ServeWebCommand(pathResolver, new CodemationConsumerConfigLoader(), pluginDiscovery, artifactsPublisher, tsRuntime, sourceMapNodeOptions, outputBuilderLoader, new ConsumerEnvLoader(), new ListenPortResolver(), nextHostConsumerServerCommandFactory, new CodemationFrontendAuthSnapshotFactory(), new FrontendAppConfigJsonCodec()), new ServeWorkerCommand(pathResolver, appConfigLoader, new AppContainerFactory()), new DbMigrateCommand(databaseMigrationsApplyService), new UserCreateCommand(new LocalUserCreator(userAdminBootstrap), userAdminCliOptionsParser), new UserListCommand(cliLogger, userAdminBootstrap, new CliDatabaseUrlDescriptor(), userAdminCliOptionsParser));
+		const consumerOutputBuilderFactory = new ConsumerOutputBuilderFactory();
+		const consumerBuildArtifactsPublisher = new ConsumerBuildArtifactsPublisher();
+		const devCommand = new DevCommand(pathResolver, tsRuntime, new DevLockFactory(), new DevSourceWatcherFactory(), cliLogger, devSessionServices, databaseMigrationsApplyService, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, new DevBootstrapSummaryFetcher(), new DevCliBannerRenderer(), new ConsumerEnvDotenvFilePredicate(), new DevTrackedProcessTreeKiller(), nextHostConsumerServerCommandFactory, new DevApiRuntimeFactory(devSessionServices.loopbackPortAllocator, appConfigLoader, pluginDiscovery), new CliDevProxyServerFactory(), new DevRebuildQueueFactory());
+		return new CliProgram(buildOptionsParser, new BuildCommand(cliLogger, pathResolver, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, tsRuntime), devCommand, new DevPluginCommand(new PluginDevConfigFactory(), devCommand), new ServeWebCommand(pathResolver, new CodemationConsumerConfigLoader(), tsRuntime, sourceMapNodeOptions, new ConsumerEnvLoader(), new ListenPortResolver(), nextHostConsumerServerCommandFactory), new ServeWorkerCommand(pathResolver, appConfigLoader, new AppContainerFactory()), new DbMigrateCommand(databaseMigrationsApplyService), new UserCreateCommand(new LocalUserCreator(userAdminBootstrap), userAdminCliOptionsParser), new UserListCommand(cliLogger, userAdminBootstrap, new CliDatabaseUrlDescriptor(), userAdminCliOptionsParser));
 	}
 };