@codemation/cli 0.0.14 → 0.0.16

package/src/consumer/ConsumerOutputBuilder.ts

@@ -374,6 +374,7 @@ export class ConsumerOutputBuilder {
             sourcePath,
           });
         }
+        await this.emitConfigSourceFile(outputAppRoot, configSourcePath, runtimeSourcePaths);
       },
     });
   }
@@ -463,6 +464,24 @@ export class ConsumerOutputBuilder {
     }
   }
 
+  private async emitConfigSourceFile(
+    outputAppRoot: string,
+    configSourcePath: string,
+    runtimeSourcePaths: ReadonlyArray<string>,
+  ): Promise<void> {
+    const normalizedConfigSourcePath = path.resolve(configSourcePath);
+    const alreadyEmitted = runtimeSourcePaths.some(
+      (sourcePath) => path.resolve(sourcePath) === normalizedConfigSourcePath,
+    );
+    if (alreadyEmitted) {
+      return;
+    }
+    await this.emitSourceFile({
+      outputAppRoot,
+      sourcePath: normalizedConfigSourcePath,
+    });
+  }
+
   private createCompilerOptions(): ts.CompilerOptions {
     const scriptTarget = this.buildOptions.target === "es2020" ? ts.ScriptTarget.ES2020 : ts.ScriptTarget.ES2022;
     return {

package/src/consumer/ConsumerOutputBuilderFactory.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "@codemation/host/next/server";
+
+import { ConsumerOutputBuilder } from "./ConsumerOutputBuilder";
+import type { ConsumerBuildOptions } from "./consumerBuildOptions.types";
+
+export class ConsumerOutputBuilderFactory {
+  create(
+    consumerRoot: string,
+    args?: Readonly<{
+      buildOptions?: ConsumerBuildOptions;
+      logger?: Logger;
+    }>,
+  ): ConsumerOutputBuilder {
+    return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions);
+  }
+}

package/src/dev/Builder.ts

@@ -4,13 +4,13 @@ import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { ListenPortResolver } from "../runtime/ListenPortResolver";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
 
-import { DevAuthSettingsLoader } from "./DevAuthSettingsLoader";
 import { DevHttpProbe } from "./DevHttpProbe";
 import { DevNextHostEnvironmentBuilder } from "./DevNextHostEnvironmentBuilder";
 import { DevSessionPortsResolver } from "./DevSessionPortsResolver";
 import { DevSessionServices } from "./DevSessionServices";
 import { DevSourceChangeClassifier } from "./DevSourceChangeClassifier";
 import { LoopbackPortAllocator } from "./LoopbackPortAllocator";
+import { NextHostEdgeSeedLoader } from "./NextHostEdgeSeedLoader";
 import { WatchRootsResolver } from "./WatchRootsResolver";
 
 export class DevSessionServicesBuilder {
@@ -25,7 +25,7 @@ export class DevSessionServicesBuilder {
       new DevSessionPortsResolver(listenPortResolver, loopbackPortAllocator),
       loopbackPortAllocator,
       new DevHttpProbe(),
-      new DevAuthSettingsLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader),
+      new NextHostEdgeSeedLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader),
       new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions),
       new WatchRootsResolver(),
       new DevSourceChangeClassifier(),

package/src/dev/DevApiRuntimeFactory.ts

@@ -21,6 +21,7 @@ export class DevApiRuntimeFactory {
       httpPort,
       workflowWebSocketPort,
       new DevApiRuntimeHost(this.configLoader, this.pluginDiscovery, {
+        configPathOverride: args.configPathOverride,
         consumerRoot: args.consumerRoot,
         env: {
           ...args.env,

package/src/dev/DevApiRuntimeHost.ts

@@ -1,4 +1,5 @@
-import type { CodemationPlugin } from "@codemation/host";
+import type { AppConfig, AppPluginLoadSummary, CodemationPlugin } from "@codemation/host";
+import { CodemationPluginPackageMetadata } from "@codemation/host";
 import {
   AppContainerFactory,
   AppContainerLifecycle,
@@ -18,13 +19,15 @@ import { CodemationTsyringeTypeInfoRegistrar } from "@codemation/host-src/presen
 import type { DevApiRuntimeContext } from "./DevApiRuntimeTypes";
 
 export class DevApiRuntimeHost {
-  private readonly pluginListMerger = new CodemationPluginListMerger();
+  private readonly pluginPackageMetadata = new CodemationPluginPackageMetadata();
+  private readonly pluginListMerger = new CodemationPluginListMerger(this.pluginPackageMetadata);
   private contextPromise: Promise<DevApiRuntimeContext> | null = null;
 
   constructor(
     private readonly configLoader: AppConfigLoader,
     private readonly pluginDiscovery: CodemationPluginDiscovery,
     private readonly args: Readonly<{
+      configPathOverride?: string;
       consumerRoot: string;
       env: NodeJS.ProcessEnv;
       runtimeWorkingDirectory: string;
@@ -62,17 +65,24 @@ export class DevApiRuntimeHost {
     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().create({
       appConfig,
@@ -96,6 +106,27 @@ export class DevApiRuntimeHost {
     return resolvedPackages.map((resolvedPackage: CodemationResolvedPluginPackage) => resolvedPackage.plugin);
   }
 
+  private createPluginLoadSummary(
+    configuredPlugins: ReadonlyArray<CodemationPlugin>,
+    discoveredPlugins: ReadonlyArray<CodemationPlugin>,
+    mergedPlugins: ReadonlyArray<CodemationPlugin>,
+  ): AppConfig["pluginLoadSummary"] {
+    const configuredPluginSet = new Set(configuredPlugins);
+    const discoveredPluginSet = new Set(discoveredPlugins);
+    const summaries: AppPluginLoadSummary[] = [];
+    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;
+  }
+
   private async detectWorkspaceRoot(startDirectory: string): Promise<string> {
     let currentDirectory = path.resolve(startDirectory);
     while (true) {

package/src/dev/DevApiRuntimeTypes.ts

@@ -10,6 +10,7 @@ export type DevApiRuntimeContext = Readonly<{
 }>;
 
 export type DevApiRuntimeFactoryArgs = Readonly<{
+  configPathOverride?: string;
   consumerRoot: string;
   env: NodeJS.ProcessEnv;
   runtimeWorkingDirectory: string;

package/src/dev/DevCliBannerRenderer.ts

@@ -39,8 +39,9 @@ export class DevCliBannerRenderer {
       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: DevBootstrapSummaryJson): void {
@@ -62,8 +63,9 @@ export class DevCliBannerRenderer {
       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`);
   }
 
   private renderFigletTitle(): string {
@@ -103,4 +105,21 @@ export class DevCliBannerRenderer {
       titleAlignment: "left",
     });
   }
+
+  private buildPluginsSection(summary: DevBootstrapSummaryJson): string {
+    const lines =
+      summary.plugins.length === 0
+        ? [chalk.dim("  (none discovered or configured)")]
+        : summary.plugins.map(
+            (plugin) => `${chalk.whiteBright(`  • ${plugin.packageName} `)}${chalk.dim(`(${plugin.source})`)}`,
+          );
+    return boxen(lines.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",
+    });
+  }
 }

package/src/dev/DevNextHostEnvironmentBuilder.ts

@@ -1,7 +1,4 @@
-import path from "node:path";
 import process from "node:process";
-import type { CodemationAuthConfig } from "@codemation/host";
-import { CodemationFrontendAuthSnapshotFactory, FrontendAppConfigJsonCodec } from "@codemation/host";
 
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
@@ -10,14 +7,12 @@ export class DevNextHostEnvironmentBuilder {
   constructor(
     private readonly consumerEnvLoader: ConsumerEnvLoader,
     private readonly sourceMapNodeOptions: SourceMapNodeOptions,
-    private readonly frontendAuthSnapshotFactory: CodemationFrontendAuthSnapshotFactory = new CodemationFrontendAuthSnapshotFactory(),
-    private readonly frontendAppConfigJsonCodec: FrontendAppConfigJsonCodec = new FrontendAppConfigJsonCodec(),
   ) {}
 
   buildConsumerUiProxy(
     args: Readonly<{
-      authConfigJson: string;
       authSecret: string;
+      configPathOverride?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
@@ -25,20 +20,18 @@ export class DevNextHostEnvironmentBuilder {
       runtimeDevUrl: string;
       skipUiAuth: boolean;
       websocketPort: number;
-      consumerOutputManifestPath?: string;
     }>,
   ): NodeJS.ProcessEnv {
     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,
       }),
       // Standalone `server.js` uses `process.env.HOSTNAME || '0.0.0.0'` for bind; Docker sets HOSTNAME to the
       // container id, which breaks loopback health checks — force IPv4 loopback for the UI child only.
@@ -50,44 +43,22 @@ export class DevNextHostEnvironmentBuilder {
 
   build(
     args: Readonly<{
-      authConfigJson: string;
       authSecret?: string;
+      configPathOverride?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
       skipUiAuth: boolean;
       websocketPort: number;
       runtimeDevUrl?: string;
-      /** Same manifest as `codemation build` / serve-web so @codemation/next-host can load consumer config (whitelabel, etc.). */
-      consumerOutputManifestPath?: string;
     }>,
   ): NodeJS.ProcessEnv {
     const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process.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,
       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,
@@ -95,17 +66,13 @@ export class DevNextHostEnvironmentBuilder {
       NODE_OPTIONS: this.sourceMapNodeOptions.appendToNodeOptions(process.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 !== undefined && args.runtimeDevUrl.trim().length > 0
         ? { CODEMATION_RUNTIME_DEV_URL: args.runtimeDevUrl.trim() }
         : {}),
     };
   }
-
-  private parseAuthConfig(authConfigJson: string): CodemationAuthConfig | undefined {
-    if (authConfigJson.trim().length === 0) {
-      return undefined;
-    }
-    const parsed = JSON.parse(authConfigJson) as CodemationAuthConfig | null;
-    return parsed ?? undefined;
-  }
 }

package/src/dev/DevRebuildQueue.ts

@@ -1,6 +1,6 @@
 export type DevRebuildRequest = Readonly<{
   changedPaths: ReadonlyArray<string>;
-  shouldRepublishConsumerOutput: boolean;
+  configPathOverride?: string;
   shouldRestartUi: boolean;
 }>;
 
@@ -47,7 +47,7 @@ export class DevRebuildQueue {
     }
     return {
       changedPaths: [...new Set([...current.changedPaths, ...next.changedPaths])],
-      shouldRepublishConsumerOutput: current.shouldRepublishConsumerOutput || next.shouldRepublishConsumerOutput,
+      configPathOverride: next.configPathOverride ?? current.configPathOverride,
       shouldRestartUi: current.shouldRestartUi || next.shouldRestartUi,
     };
   }

package/src/dev/DevSessionServices.ts

@@ -1,12 +1,12 @@
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
 
-import { DevAuthSettingsLoader } from "./DevAuthSettingsLoader";
 import { DevHttpProbe } from "./DevHttpProbe";
 import { DevNextHostEnvironmentBuilder } from "./DevNextHostEnvironmentBuilder";
 import { DevSessionPortsResolver } from "./DevSessionPortsResolver";
 import { DevSourceChangeClassifier } from "./DevSourceChangeClassifier";
 import { LoopbackPortAllocator } from "./LoopbackPortAllocator";
+import { NextHostEdgeSeedLoader } from "./NextHostEdgeSeedLoader";
 import { WatchRootsResolver } from "./WatchRootsResolver";
 
 /**
@@ -19,7 +19,7 @@ export class DevSessionServices {
     readonly sessionPorts: DevSessionPortsResolver,
     readonly loopbackPortAllocator: LoopbackPortAllocator,
     readonly devHttpProbe: DevHttpProbe,
-    readonly devAuthLoader: DevAuthSettingsLoader,
+    readonly nextHostEdgeSeedLoader: NextHostEdgeSeedLoader,
     readonly nextHostEnvBuilder: DevNextHostEnvironmentBuilder,
     readonly watchRootsResolver: WatchRootsResolver,
     readonly sourceChangeClassifier: DevSourceChangeClassifier,

package/src/dev/DevSourceChangeClassifier.ts

@@ -1,21 +1,16 @@
 import path from "node:path";
 
 export class DevSourceChangeClassifier {
-  private static readonly configFileNames = new Set([
+  private static readonly uiConfigFileNames = new Set([
     "codemation.config.ts",
     "codemation.config.js",
     "codemation.config.mjs",
   ]);
-
-  shouldRepublishConsumerOutput(
-    args: Readonly<{
-      changedPaths: ReadonlyArray<string>;
-      consumerRoot: string;
-    }>,
-  ): boolean {
-    const resolvedConsumerRoot = path.resolve(args.consumerRoot);
-    return args.changedPaths.some((changedPath) => this.isPathInsideDirectory(changedPath, resolvedConsumerRoot));
-  }
+  private static readonly pluginConfigFileNames = new Set([
+    "codemation.plugin.ts",
+    "codemation.plugin.js",
+    "codemation.plugin.mjs",
+  ]);
 
   requiresUiRestart(
     args: Readonly<{
@@ -40,10 +35,15 @@ export class DevSourceChangeClassifier {
       return false;
     }
     const relativePath = path.relative(consumerRoot, resolvedPath);
-    if (DevSourceChangeClassifier.configFileNames.has(path.basename(relativePath))) {
+    const fileName = path.basename(relativePath);
+    if (DevSourceChangeClassifier.uiConfigFileNames.has(fileName)) {
       // Config changes affect auth and branding projections consumed by the packaged Next host.
       return true;
     }
+    if (DevSourceChangeClassifier.pluginConfigFileNames.has(fileName)) {
+      // Plugin sandbox configs also define workflows, so keep them on the cheap runtime-only reload path.
+      return false;
+    }
     if (relativePath.startsWith(path.join("src", "workflows"))) {
       return false;
     }

package/src/dev/{DevAuthSettingsLoader.ts → NextHostEdgeSeedLoader.ts}

@@ -4,13 +4,12 @@ import { CodemationConsumerConfigLoader } from "@codemation/host/server";
 
 import type { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 
-export type DevResolvedAuthSettings = Readonly<{
-  authConfigJson: string;
+export type NextHostEdgeSeed = Readonly<{
   authSecret: string;
-  skipUiAuth: boolean;
+  uiAuthEnabled: boolean;
 }>;
 
-export class DevAuthSettingsLoader {
+export class NextHostEdgeSeedLoader {
   static readonly defaultDevelopmentAuthSecret = "codemation-dev-auth-secret-not-for-production";
 
   constructor(
@@ -25,13 +24,18 @@ export class DevAuthSettingsLoader {
     return randomUUID();
   }
 
-  async loadForConsumer(consumerRoot: string): Promise<DevResolvedAuthSettings> {
-    const resolution = await this.configLoader.load({ consumerRoot });
+  async loadForConsumer(
+    consumerRoot: string,
+    options?: Readonly<{ configPathOverride?: string }>,
+  ): Promise<NextHostEdgeSeed> {
+    const resolution = await this.configLoader.load({
+      consumerRoot,
+      configPathOverride: options?.configPathOverride,
+    });
     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,
+      uiAuthEnabled: resolution.config.auth?.allowUnauthenticatedInDevelopment !== true,
     };
   }
 
@@ -40,6 +44,6 @@ export class DevAuthSettingsLoader {
     if (configuredSecret && configuredSecret.trim().length > 0) {
       return configuredSecret;
     }
-    return DevAuthSettingsLoader.defaultDevelopmentAuthSecret;
+    return NextHostEdgeSeedLoader.defaultDevelopmentAuthSecret;
   }
 }

package/src/dev/PluginDevConfigFactory.ts

@@ -0,0 +1,64 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export type PluginDevConfigBootstrap = Readonly<{
+  configPath: string;
+}>;
+
+export class PluginDevConfigFactory {
+  async prepare(pluginRoot: string): Promise<PluginDevConfigBootstrap> {
+    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,
+    };
+  }
+
+  private async resolvePluginEntryPath(pluginRoot: string): Promise<string> {
+    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/".');
+  }
+
+  private createConfigSource(configPath: string, pluginEntryPath: string): string {
+    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");
+  }
+
+  private toRelativeImportPath(fromPath: string, targetPath: string): string {
+    const relativePath = path.relative(path.dirname(fromPath), targetPath).replace(/\\/g, "/");
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  }
+
+  private async exists(filePath: string): Promise<boolean> {
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/build/ConsumerBuildArtifactsPublisher.ts

@@ -1,77 +0,0 @@
-import type { CodemationDiscoveredPluginPackage } from "@codemation/host/server";
-import { randomUUID } from "node:crypto";
-import { mkdir, rename, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-import type { ConsumerOutputBuildSnapshot } from "../consumer/ConsumerOutputBuilder";
-
-export type ConsumerBuildManifest = Readonly<{
-  buildVersion: string;
-  consumerRoot: string;
-  entryPath: string;
-  manifestPath: string;
-  pluginEntryPath: string;
-  workflowSourcePaths: ReadonlyArray<string>;
-}>;
-
-export class ConsumerBuildArtifactsPublisher {
-  async publish(
-    snapshot: ConsumerOutputBuildSnapshot,
-    discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>,
-  ): Promise<ConsumerBuildManifest> {
-    const pluginEntryPath = await this.writeDiscoveredPluginsOutput(snapshot, discoveredPlugins);
-    return await this.writeBuildManifest(snapshot, pluginEntryPath);
-  }
-
-  private async writeDiscoveredPluginsOutput(
-    snapshot: ConsumerOutputBuildSnapshot,
-    discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>,
-  ): Promise<string> {
-    const outputPath = path.resolve(snapshot.emitOutputRoot, "plugins.js");
-    await mkdir(path.dirname(outputPath), { recursive: true });
-    const outputLines: string[] = ["const codemationDiscoveredPlugins = [];", ""];
-    discoveredPlugins.forEach((discoveredPlugin: CodemationDiscoveredPluginPackage, index: number) => {
-      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;
-  }
-
-  private async writeBuildManifest(
-    snapshot: ConsumerOutputBuildSnapshot,
-    pluginEntryPath: string,
-  ): Promise<ConsumerBuildManifest> {
-    const manifest: ConsumerBuildManifest = {
-      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;
-  }
-}

package/src/consumer/Loader.ts

@@ -1,8 +0,0 @@
-import type { ConsumerBuildOptions } from "./consumerBuildOptions.types";
-import { ConsumerOutputBuilder } from "./ConsumerOutputBuilder";
-
-export class ConsumerOutputBuilderLoader {
-  create(consumerRoot: string, buildOptions: ConsumerBuildOptions): ConsumerOutputBuilder {
-    return new ConsumerOutputBuilder(consumerRoot, undefined, buildOptions);
-  }
-}

package/src/dev/DevConsumerPublishBootstrap.ts

@@ -1,30 +0,0 @@
-import type { Logger } from "@codemation/host/next/server";
-import { CodemationPluginDiscovery } from "@codemation/host/server";
-
-import { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
-import { ConsumerBuildOptionsParser } from "../build/ConsumerBuildOptionsParser";
-import { ConsumerOutputBuilderLoader } from "../consumer/Loader";
-import type { CliPaths } from "../path/CliPathResolver";
-
-/**
- * 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).
- */
-export class DevConsumerPublishBootstrap {
-  constructor(
-    private readonly cliLogger: Logger,
-    private readonly pluginDiscovery: CodemationPluginDiscovery,
-    private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
-    private readonly outputBuilderLoader: ConsumerOutputBuilderLoader,
-    private readonly buildOptionsParser: ConsumerBuildOptionsParser,
-  ) {}
-
-  async ensurePublished(paths: CliPaths): Promise<void> {
-    const buildOptions = this.buildOptionsParser.parse({});
-    const builder = this.outputBuilderLoader.create(paths.consumerRoot, buildOptions);
-    const snapshot = await builder.ensureBuilt();
-    const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
-    await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
-    this.cliLogger.debug(`Dev: consumer output published (${snapshot.buildVersion}).`);
-  }
-}