@codemation/cli 0.0.14 → 0.0.16

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

@@ -1,17 +1,17 @@
 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";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { execFile, spawn } from "node:child_process";
+import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { config, parse } from "dotenv";
 import { watch } from "chokidar";
+import { randomUUID } from "node:crypto";
+import { access, copyFile, cp, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import ts from "typescript";
+import { fileURLToPath } from "node:url";
 import { PrismaMigrationDeployer } from "@codemation/host/persistence";
 import boxen from "boxen";
 import chalk from "chalk";
@@ -25,52 +25,6 @@ import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createServer as createServer$1 } from "node:net";
 import { Command } from "commander";
 
-//#region src/build/ConsumerBuildArtifactsPublisher.ts
-var ConsumerBuildArtifactsPublisher = class {
-	async publish(snapshot, discoveredPlugins) {
-		const pluginEntryPath = await this.writeDiscoveredPluginsOutput(snapshot, discoveredPlugins);
-		return await this.writeBuildManifest(snapshot, pluginEntryPath);
-	}
-	async writeDiscoveredPluginsOutput(snapshot, discoveredPlugins) {
-		const outputPath = path.resolve(snapshot.emitOutputRoot, "plugins.js");
-		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`;
-			outputLines.push(`const pluginModule${index} = await import(${JSON.stringify(pluginFileUrl)});`);
-			outputLines.push(`const pluginValue${index} = ${exportNameAccessor};`);
-			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") {`);
-			outputLines.push(`  codemationDiscoveredPlugins.push(new pluginValue${index}());`);
-			outputLines.push("}");
-			outputLines.push("");
-		});
-		outputLines.push("export { codemationDiscoveredPlugins };");
-		outputLines.push("export default codemationDiscoveredPlugins;");
-		outputLines.push("");
-		await writeFile(outputPath, outputLines.join("\n"), "utf8");
-		return outputPath;
-	}
-	async writeBuildManifest(snapshot, pluginEntryPath) {
-		const manifest = {
-			buildVersion: snapshot.buildVersion,
-			consumerRoot: snapshot.consumerRoot,
-			entryPath: snapshot.outputEntryPath,
-			manifestPath: snapshot.manifestPath,
-			pluginEntryPath,
-			workflowSourcePaths: snapshot.workflowSourcePaths
-		};
-		await mkdir(path.dirname(snapshot.manifestPath), { recursive: true });
-		const temporaryManifestPath = `${snapshot.manifestPath}.${snapshot.buildVersion}.${randomUUID()}.tmp`;
-		await writeFile(temporaryManifestPath, JSON.stringify(manifest, null, 2), "utf8");
-		await rename(temporaryManifestPath, snapshot.manifestPath);
-		return manifest;
-	}
-};
-
-//#endregion
 //#region src/build/ConsumerBuildOptionsParser.ts
 var ConsumerBuildOptionsParser = class {
 	parse(args) {
@@ -90,23 +44,18 @@ var ConsumerBuildOptionsParser = class {
 //#endregion
 //#region src/commands/BuildCommand.ts
 var BuildCommand = class {
-	constructor(cliLogger, pathResolver, pluginDiscovery, artifactsPublisher, tsRuntime, outputBuilderLoader) {
+	constructor(cliLogger, pathResolver, consumerOutputBuilderFactory, tsRuntime) {
 		this.cliLogger = cliLogger;
 		this.pathResolver = pathResolver;
-		this.pluginDiscovery = pluginDiscovery;
-		this.artifactsPublisher = artifactsPublisher;
+		this.consumerOutputBuilderFactory = consumerOutputBuilderFactory;
 		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 discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
-		const manifest = await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
+		const snapshot = await this.consumerOutputBuilderFactory.create(paths.consumerRoot, { buildOptions }).ensureBuilt();
 		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(`Workflow modules emitted: ${snapshot.workflowSourcePaths.length}`);
 	}
 };
 
@@ -125,7 +74,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, devBootstrapSummaryFetcher, devCliBannerRenderer, consumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory, devApiRuntimeFactory, cliDevProxyServerFactory, devRebuildQueueFactory) {
 		this.pathResolver = pathResolver;
 		this.tsRuntime = tsRuntime;
 		this.devLockFactory = devLockFactory;
@@ -135,7 +84,6 @@ var DevCommand = class {
 		this.databaseMigrationsApplyService = databaseMigrationsApplyService;
 		this.devBootstrapSummaryFetcher = devBootstrapSummaryFetcher;
 		this.devCliBannerRenderer = devCliBannerRenderer;
-		this.devConsumerPublishBootstrap = devConsumerPublishBootstrap;
 		this.consumerEnvDotenvFilePredicate = consumerEnvDotenvFilePredicate;
 		this.devTrackedProcessTreeKiller = devTrackedProcessTreeKiller;
 		this.nextHostConsumerServerCommandFactory = nextHostConsumerServerCommandFactory;
@@ -145,10 +93,10 @@ var DevCommand = class {
 	}
 	async execute(args) {
 		const paths = await this.pathResolver.resolve(args.consumerRoot);
+		const commandName = args.commandName ?? "dev";
 		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,24 +108,28 @@ 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);
 			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 {
 			processState.stopRequested = true;
@@ -190,14 +142,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 +175,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 +272,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 +308,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 +324,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 +345,6 @@ var DevCommand = class {
 		proxyServer.setBuildStatus("building");
 		proxyServer.broadcastBuildStarted();
 		try {
-			if (request.shouldRepublishConsumerOutput) await this.devConsumerPublishBootstrap.ensurePublished(prepared.paths);
 			await this.stopCurrentRuntime(state, proxyServer);
 			process$1.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
 			const runtime = await this.createRuntime(prepared);
@@ -418,7 +367,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 +414,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 +427,27 @@ var DevCommand = class {
 			}
 		});
 	}
-	logPackagedUiDevHintWhenNeeded(devMode, gatewayPort) {
+	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 +455,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 +484,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),
@@ -978,6 +925,7 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 						sourcePath
 					});
 				}
+				await this.emitConfigSourceFile(outputAppRoot, configSourcePath, runtimeSourcePaths);
 			}
 		});
 	}
@@ -1036,6 +984,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 {
@@ -1289,10 +1245,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);
 	}
 };
 
@@ -1464,8 +1420,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 +1449,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 +1490,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"
+		});
 	}
 };
 
@@ -2089,7 +2042,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 +2072,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 +2102,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 +2233,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 +2290,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 +2338,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,24 +2382,21 @@ 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) {
 		return {
 			...this.build({
-				authConfigJson: args.authConfigJson,
 				authSecret: args.authSecret,
+				configPathOverride: args.configPathOverride,
 				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,
@@ -2463,27 +2404,11 @@ var DevNextHostEnvironmentBuilder = class {
 		};
 	}
 	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
-		});
 		return {
-			...merged,
+			...this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process$1.env),
 			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_UI_AUTH_ENABLED: String(!args.skipUiAuth),
 			CODEMATION_WS_PORT: String(args.websocketPort),
 			NEXT_PUBLIC_CODEMATION_WS_PORT: String(args.websocketPort),
 			CODEMATION_DEV_SERVER_TOKEN: args.developmentServerToken,
@@ -2491,13 +2416,11 @@ 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;
-	}
 };
 
 //#endregion
@@ -2522,13 +2445,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 +2461,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 +2483,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 +2514,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 +2570,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 +2876,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 +2900,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 +3170,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 +3180,8 @@ 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 devCommand = new DevCommand(pathResolver, tsRuntime, new DevLockFactory(), new DevSourceWatcherFactory(), cliLogger, devSessionServices, databaseMigrationsApplyService, 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, new ConsumerOutputBuilderFactory(), 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));
 	}
 };