every-plugin 2.10.0 → 3.0.0-rc.0

package/src/build/rspack/compose.ts

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import type { Compiler, RspackPluginInstance } from "@rspack/core";
+import { FixMfDataUriPlugin } from "./fix-mf-data-uri-plugin";
+import { EmitPluginManifest, EveryPluginBuild } from "./plugin";
+
+class EveryPluginComposedBuild implements RspackPluginInstance {
+  name = "EveryPluginComposedBuild";
+
+  constructor(private readonly dts: boolean = false) {}
+
+  apply(compiler: Compiler) {
+    new EmitPluginManifest().apply(compiler);
+    new EveryPluginBuild({ dts: this.dts }).apply(compiler);
+    new FixMfDataUriPlugin().apply(compiler);
+  }
+}
+
+export interface PluginBaseConfigOptions {
+  drizzle?: boolean;
+  externals?: string[];
+  /** Concrete rspack fields to merge over the defaults (devtool, infrastructureLogging, ...). */
+  rspack?: Partial<PluginBaseConfig>;
+}
+
+const pluginRequire = createRequire(import.meta.url);
+
+/** Config filenames that mark a project root, nearest-first. Authored
+ * descriptor projects (the platform) carry bos.app.ts; generated child
+ * projects carry bos.config.json. */
+const CONFIG_FILENAMES = ["bos.config.json", "bos.app.ts"] as const;
+
+export function findBosConfigPath(from: string = process.cwd()): string | null {
+  let current = path.resolve(from);
+  while (true) {
+    for (const filename of CONFIG_FILENAMES) {
+      const candidate = path.join(current, filename);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function loadDrizzleMigrationsPlugin(): ((...args: unknown[]) => unknown) | null {
+  try {
+    const mod = pluginRequire("@proj-airi/unplugin-drizzle-orm-migrations/rspack");
+    return (mod as { default?: (...args: unknown[]) => unknown }).default ?? mod;
+  } catch {
+    return null;
+  }
+}
+
+export interface PluginBaseConfig {
+  externals: string[];
+  devtool: false | "source-map";
+  plugins: unknown[];
+  infrastructureLogging: { level: "error" };
+  stats: "errors-warnings";
+}
+
+export function createPluginBaseConfig(options: PluginBaseConfigOptions = {}): PluginBaseConfig {
+  const shouldDeploy = process.env.DEPLOY === "true";
+  const plugins: unknown[] = [new EveryPluginComposedBuild(false)];
+
+  if (options.drizzle !== false) {
+    const drizzlePlugin = loadDrizzleMigrationsPlugin();
+    if (drizzlePlugin) {
+      plugins.push(drizzlePlugin());
+    } else if (options.drizzle === true) {
+      throw new Error(
+        "createPluginBaseConfig({ drizzle: true }) requires @proj-airi/unplugin-drizzle-orm-migrations to be installed.",
+      );
+    }
+  }
+
+  return {
+    ...options.rspack,
+    externals: options.externals ?? options.rspack?.externals ?? ["pg", "@electric-sql/pglite"],
+    devtool: options.rspack?.devtool ?? (shouldDeploy ? false : "source-map"),
+    plugins,
+    infrastructureLogging: options.rspack?.infrastructureLogging ?? { level: "error" },
+    stats: options.rspack?.stats ?? "errors-warnings",
+  };
+}

package/src/build/rspack/fix-mf-data-uri-plugin.ts

@@ -1,10 +1,14 @@
 import type { Compiler, RspackPluginInstance } from "@rspack/core";
 
 const MF_DATA_URI_MARKER = "data:text/javascript,";
+const NODE_MODULES_IMPORT_RE = /(["'])\/[^"']*?\/node_modules\/([^"']*)\1/g;
 
 export class FixMfDataUriPlugin implements RspackPluginInstance {
   name = "FixMfDataUriPlugin";
 
+  /** Bare specifier → on-disk absolute path, learned while rewriting. */
+  private redirects = new Map<string, string>();
+
   apply(compiler: Compiler) {
     compiler.hooks.compilation.tap(this.name, (_compilation, { normalModuleFactory }) => {
       normalModuleFactory.hooks.beforeResolve.tap(this.name, (resolveData) => {
@@ -12,6 +16,12 @@ export class FixMfDataUriPlugin implements RspackPluginInstance {
         if (!resolveData.request.includes(MF_DATA_URI_MARKER)) return;
         this.reencodeDataUri(resolveData);
       });
+      normalModuleFactory.hooks.resolve.tap(this.name, (resolveData) => {
+        const target = this.redirects.get(resolveData?.request ?? "");
+        if (target) {
+          resolveData.request = target;
+        }
+      });
     });
   }
 
@@ -24,22 +34,23 @@ export class FixMfDataUriPlugin implements RspackPluginInstance {
     const prefix = request.substring(0, contentStart);
     const rawContent = request.substring(contentStart);
 
-    if (isAlreadyEncoded(rawContent)) return;
-
-    const decoded = safeDecode(rawContent);
+    // The MF runtime's and rsbuild's generated data-URI modules import their
+    // runtime pieces by absolute node_modules paths (`require.resolve` output),
+    // which differ per machine. Rewriting them to bare specifiers keeps the
+    // module — and therefore the module id space — machine-independent; the
+    // recorded redirects resolve those specifiers back to this machine's
+    // on-disk copies while the request (and thus the module id) stays bare.
+    const decoded = safeDecode(rawContent).replace(
+      NODE_MODULES_IMPORT_RE,
+      (match, _quote: string, rest: string) => {
+        this.redirects.set(rest, match.slice(1, -1));
+        return _quote + rest + _quote;
+      },
+    );
     resolveData.request = prefix + encodeURIComponent(decoded);
   }
 }
 
-function isAlreadyEncoded(content: string): boolean {
-  try {
-    const decoded = decodeURIComponent(content);
-    return decoded !== content;
-  } catch {
-    return false;
-  }
-}
-
 function safeDecode(content: string): string {
   try {
     return decodeURIComponent(content);

package/src/build/rspack/generated-config.ts

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { findBosConfigPath } from "./compose";
+
+export { findBosConfigPath };
+
+function generatedRspackConfig(hasOverrides: boolean): string {
+  return `import { createPluginBaseConfig } from "every-plugin/build/rspack";
+${hasOverrides ? `import buildOverrides from "../build.config.ts";\n` : ""}
+export default createPluginBaseConfig(${hasOverrides ? "buildOverrides" : "{}"});
+`;
+}
+
+/**
+ * Ensures the synthesized rspack config exists for workspaces that no longer
+ * ship their own `rspack.config.js`. Returns the workspace-relative config
+ * path to pass via `--config`, or `null` when the workspace has its own
+ * `rspack.config.js` and bare `rspack build` should be used.
+ */
+export function ensureGeneratedRspackConfig(cwd: string = process.cwd()): string | null {
+  if (fs.existsSync(path.join(cwd, "rspack.config.js"))) return null;
+
+  const overridesPath = path.resolve(cwd, "build.config.ts");
+  const hasOverrides = fs.existsSync(overridesPath);
+  const generatedDir = path.join(cwd, ".every-plugin");
+  const generatedConfig = path.join(generatedDir, "rspack.config.generated.mjs");
+  fs.mkdirSync(generatedDir, { recursive: true });
+  fs.writeFileSync(generatedConfig, generatedRspackConfig(hasOverrides));
+
+  console.log(
+    "[every-plugin] rspack.config.js not found — using the every-plugin build composition.",
+  );
+  return path.join(".every-plugin", "rspack.config.generated.mjs");
+}

package/src/build/rspack/index.ts

@@ -1,14 +1,19 @@
 export {
-  getMajorMinorVersion,
   getPluginSharedDependencies,
-  getPluginSharedDependenciesVersionRange,
+  isEffectCriticalSharedDep,
   type SharedDependencies,
   type SharedDependencyConfig,
-} from "../shared-deps";
+} from "../../shared-deps-spec";
+export { BuildReportPlugin } from "./build-report-plugin";
+export {
+  createPluginBaseConfig,
+  type PluginBaseConfig,
+  type PluginBaseConfigOptions,
+} from "./compose";
 export { FixMfDataUriPlugin } from "./fix-mf-data-uri-plugin";
 export {
   EmitPluginManifest,
-  EveryPluginDevServer,
-  type EveryPluginOptions,
+  EveryPluginBuild,
+  type EveryPluginBuildOptions,
   type PluginManifestEmitterOptions,
 } from "./plugin";

package/src/build/rspack/module-federation.ts

@@ -1,4 +1,4 @@
-import { getPluginSharedDependencies } from "../shared-deps";
+import { getPluginSharedDependencies } from "../../shared-deps-spec";
 import type { PluginInfo } from "./utils";
 
 export function buildSharedDependencies(_pluginInfo: PluginInfo) {

package/src/build/rspack/plugin.ts

@@ -3,26 +3,25 @@ import fs from "node:fs";
 import path from "node:path";
 import { ModuleFederationPlugin } from "@module-federation/enhanced/rspack";
 import type { Compiler, RspackPluginInstance } from "@rspack/core";
-import { setupPluginMiddleware } from "./dev-server-middleware";
+import {
+  DEV_ENTRY_FILENAME,
+  findHashedEntry,
+  isBuildInvocation,
+  uiEntryFilename,
+} from "../artifact-names";
+import { CONTRACT_TYPES_FILE, generateContractTypes } from "../contract-types";
+import { BuildReportPlugin } from "./build-report-plugin";
+import { ChunkCompletenessPlugin } from "./chunk-completeness-plugin";
 import { buildSharedDependencies } from "./module-federation";
-import { getPluginInfo, loadDevConfig } from "./utils";
+import { getPluginInfo } from "./utils";
 
-export interface EveryPluginOptions {
-  devConfigPath?: string;
-  port?: number;
-  pluginId?: string;
+export interface EveryPluginBuildOptions {
   dts?: boolean;
 }
 
-export interface AdditionalExport {
-  srcPath: string;
-  exportNames: string[];
-}
-
 export interface PluginManifestEmitterOptions {
   manifestFileName?: string;
   contractFileName?: string;
-  additionalExports?: AdditionalExport[];
 }
 
 export class EmitPluginManifest implements RspackPluginInstance {
@@ -42,9 +41,22 @@ export class EmitPluginManifest implements RspackPluginInstance {
         const contractFileName = this.options.contractFileName ?? "contract.d.ts";
         const manifestFileName = this.options.manifestFileName ?? "plugin.manifest.json";
 
-        const sourceContractPath = path.join(context, "types", contractFileName);
+        let generationError: string | null = null;
+        try {
+          const status = await generateContractTypes(context);
+          if (status === "generated") {
+            console.log(`[EmitPluginManifest] Contract types regenerated (${context}).`);
+          }
+        } catch (error) {
+          generationError = error instanceof Error ? error.message : String(error);
+        }
+
+        if (generationError) {
+          console.warn(`[EmitPluginManifest] Skipping manifest generation — ${generationError}`);
+          return;
+        }
 
-        let contractTypes: string;
+        const sourceContractPath = path.join(context, CONTRACT_TYPES_FILE);
 
         const tryReadFile = async (filePath: string): Promise<string | null> => {
           if (!fs.existsSync(filePath)) {
@@ -61,24 +73,18 @@ export class EmitPluginManifest implements RspackPluginInstance {
           }
         };
 
-        contractTypes = (await tryReadFile(sourceContractPath)) ?? "";
+        const contractTypes = (await tryReadFile(sourceContractPath)) ?? "";
 
         if (!contractTypes) {
-          const packageDir = context.split("/").pop();
-          const nestedPath = path.join(context, "types", packageDir ?? "", "src", contractFileName);
-
-          contractTypes = (await tryReadFile(nestedPath)) ?? "";
-
-          if (!contractTypes) {
-            console.warn(
-              `[EmitPluginManifest] Contract file not found at ${sourceContractPath} or ${nestedPath}. ` +
-                `Skipping manifest generation.`,
-            );
-            return;
-          }
+          console.warn(
+            `[EmitPluginManifest] No contract types at ${sourceContractPath} ` +
+              `(no src/contract.ts in this workspace?). Skipping manifest generation.`,
+          );
+          return;
         }
 
         const contractSha256 = crypto.createHash("sha256").update(contractTypes).digest("hex");
+        const hashedEntry = findHashedEntry(Object.keys(compilation.assets), "remoteEntry");
         const manifest: Record<string, unknown> = {
           schemaVersion: 1,
           kind: "every-plugin/manifest",
@@ -87,7 +93,7 @@ export class EmitPluginManifest implements RspackPluginInstance {
             version: pluginInfo.version,
           },
           runtime: {
-            remoteEntry: "./remoteEntry.js",
+            remoteEntry: `./${hashedEntry ?? DEV_ENTRY_FILENAME}`,
           },
           contract: {
             kind: "orpc",
@@ -100,37 +106,6 @@ export class EmitPluginManifest implements RspackPluginInstance {
           },
         };
 
-        const additionalExportsEntries: Array<{ path: string; exports: string[]; sha256: string }> =
-          [];
-
-        if (this.options.additionalExports?.length) {
-          for (const additional of this.options.additionalExports) {
-            const sourcePath = path.join(context, "types", additional.srcPath);
-            const content = await tryReadFile(sourcePath);
-            if (!content) {
-              console.warn(
-                `[EmitPluginManifest] Additional export file not found at ${sourcePath}. Skipping.`,
-              );
-              continue;
-            }
-            const sha256 = crypto.createHash("sha256").update(content).digest("hex");
-            const distPath = `./types/${additional.srcPath}`;
-            additionalExportsEntries.push({
-              path: distPath,
-              exports: additional.exportNames,
-              sha256,
-            });
-
-            if (rawSource) {
-              compilation.emitAsset(`types/${additional.srcPath}`, new rawSource(content));
-            }
-          }
-
-          if (additionalExportsEntries.length > 0) {
-            manifest.additionalExports = additionalExportsEntries;
-          }
-        }
-
         if (rawSource) {
           compilation.emitAsset(
             manifestFileName,
@@ -143,27 +118,19 @@ export class EmitPluginManifest implements RspackPluginInstance {
   }
 }
 
-export class EveryPluginDevServer implements RspackPluginInstance {
-  name = "EveryPluginDevServer";
+export class EveryPluginBuild implements RspackPluginInstance {
+  name = "EveryPluginBuild";
 
-  constructor(private options: EveryPluginOptions = {}) {}
+  constructor(private options: EveryPluginBuildOptions = {}) {}
 
   apply(compiler: Compiler) {
     const pluginInfo = getPluginInfo(compiler.options.context || process.cwd());
-    const devConfig = loadDevConfig(this.options.devConfigPath || "./plugin.dev.ts");
-    const port = Number(process.env.PORT) || this.options.port || devConfig?.port || 3999;
 
     this.configureDefaults(compiler, pluginInfo);
 
-    if (!compiler.options.devServer) {
-      compiler.options.devServer = {};
-    }
-
-    this.configureDevServer(compiler, pluginInfo, devConfig, port);
-
     new ModuleFederationPlugin({
       name: pluginInfo.normalizedName,
-      filename: "remoteEntry.js",
+      filename: uiEntryFilename({ isBuild: isBuildInvocation() }),
       dts: this.options.dts !== false,
       manifest: {},
       runtimePlugins: [require.resolve("@module-federation/node/runtimePlugin")],
@@ -175,6 +142,9 @@ export class EveryPluginDevServer implements RspackPluginInstance {
       shareStrategy: "version-first",
     }).apply(compiler);
 
+    new BuildReportPlugin().apply(compiler);
+    new ChunkCompletenessPlugin().apply(compiler);
+
     if (this.options.dts === false) {
       compiler.options.plugins = (compiler.options.plugins ?? []).filter(
         (p) =>
@@ -194,7 +164,10 @@ export class EveryPluginDevServer implements RspackPluginInstance {
     compiler.options.output.uniqueName = pluginInfo.normalizedName;
     compiler.options.output.publicPath = "auto";
     compiler.options.output.path = path.resolve(context, "dist");
-    compiler.options.output.clean = true;
+    // Watch rebuilds must not wipe dist: the dev serve static handler serves
+    // this directory, and a clean on every rebuild opens a window where
+    // remoteEntry.js 404s for any consumer that loads mid-rebuild.
+    compiler.options.output.clean = !compiler.options.watch;
     compiler.options.output.library = { type: "commonjs-module" };
 
     if (!compiler.options.target) {
@@ -217,11 +190,38 @@ export class EveryPluginDevServer implements RspackPluginInstance {
 
     this.ensureTypeScriptLoader(compiler);
 
+    if (!compiler.options.optimization) {
+      compiler.options.optimization = {};
+    }
+    // rspack 2.x splitChunks re-ids the final chunk graph while the federation
+    // get-factory codegen keeps pre-split ids — the entry then references
+    // chunks that were never emitted (ChunkCompletenessPlugin's exact failure
+    // mode). Splitting off keeps the emitted bundle self-consistent.
+    compiler.options.optimization.splitChunks = false;
+    // The default deterministic module ids hash module identifiers that embed
+    // absolute resource paths, so the same source builds to different id
+    // spaces on different machines (host deploy train vs the image's
+    // dist-builder stage). A mixed-generation load — CDN-pinned entry +
+    // staged chunks — then splices two incompatible id spaces and fails with
+    // "__webpack_modules__[r] is not a function". Named ids derive from
+    // context-relative requests, keeping builds machine-independent and the
+    // two generations semantically identical.
+    compiler.options.optimization.moduleIds = "named";
+
     if (!compiler.options.resolve) {
       compiler.options.resolve = {};
     }
     compiler.options.resolve.extensions = ["...", ".tsx", ".ts"];
+    // Source-first for local flows: resolve framework packages through the
+    // `development` export condition (TS source) unless DEPLOY=true — the
+    // manual dist-first switch deploy-identical builds opt into. (NODE_ENV
+    // is unusable as the gate here: the rspack CLI defaults it to
+    // "production" for every `build` invocation, including local dev watch.)
+    // byDependency entries inherit the root conditions via "...", so
+    // dropping the strip lets esm/cjs deps pick up `development` too.
+    const sourceFirst = process.env.DEPLOY !== "true";
     compiler.options.resolve.conditionNames = [
+      ...(sourceFirst ? ["development"] : []),
       "webpack",
       "import",
       "module",
@@ -229,7 +229,18 @@ export class EveryPluginDevServer implements RspackPluginInstance {
       "node",
       "default",
     ];
-    if (compiler.options.resolve.byDependency) {
+    if (sourceFirst) {
+      // Source-resolved TS packages (e.g. better-near-auth) use node-style
+      // `.js` specifiers for their own relative imports; map them to the
+      // on-disk `.ts` sources. `.js` stays first in the expansion: the alias
+      // picks the first target that exists on disk, and .ts-first made
+      // packages that also ship index.ts (e.g. @scure/base) resolve their
+      // TypeScript over their real JavaScript entry.
+      compiler.options.resolve.extensionAlias = {
+        ".js": [".js", ".ts", ".tsx"],
+      };
+    }
+    if (!sourceFirst && compiler.options.resolve.byDependency) {
       for (const depType of Object.keys(compiler.options.resolve.byDependency)) {
         const depConfig = (
           compiler.options.resolve.byDependency as Record<string, { conditionNames?: string[] }>
@@ -255,6 +266,25 @@ export class EveryPluginDevServer implements RspackPluginInstance {
       compiler.options.module.rules = [];
     }
 
+    // Source-first resolution pulls every-plugin src into the graph, which
+    // imports package.json (runtime/mf-config.ts). The MF shared chunks
+    // must emit it as a json module, not parse it as JavaScript.
+    const hasJsonRule = compiler.options.module.rules.some(
+      (rule: any) =>
+        typeof rule === "object" &&
+        rule !== null &&
+        "test" in rule &&
+        rule.test instanceof RegExp &&
+        rule.test.test(".json"),
+    );
+
+    if (!hasJsonRule) {
+      compiler.options.module.rules.push({
+        test: /\.json$/,
+        type: "json",
+      } as any);
+    }
+
     const hasTsLoader = compiler.options.module.rules.some(
       (rule: any) =>
         typeof rule === "object" &&
@@ -272,36 +302,4 @@ export class EveryPluginDevServer implements RspackPluginInstance {
       });
     }
   }
-
-  private configureDevServer(compiler: Compiler, pluginInfo: any, devConfig: any, port: number) {
-    if (!compiler.options.devServer) {
-      return;
-    }
-
-    const context = compiler.options.context || process.cwd();
-    const originalSetup = compiler.options.devServer.setupMiddlewares;
-
-    compiler.options.devServer.port = port;
-    compiler.options.devServer.static = path.join(context, "dist");
-    compiler.options.devServer.hot = true;
-    compiler.options.devServer.devMiddleware = { writeToDisk: true };
-    compiler.options.devServer.headers = {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-      "Access-Control-Allow-Headers": "X-Requested-With, content-type, Authorization",
-    };
-
-    compiler.options.devServer.client = {
-      logging: "warn",
-      overlay: {
-        warnings: false,
-        errors: true,
-      },
-    };
-
-    compiler.options.devServer.setupMiddlewares = (middlewares, devServer) => {
-      setupPluginMiddleware(devServer, pluginInfo, devConfig, port);
-      return originalSetup ? originalSetup(middlewares, devServer) : middlewares;
-    };
-  }
 }

package/src/build/rspack/utils.ts

@@ -1,6 +1,12 @@
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
-import { getNormalizedRemoteName } from "every-plugin/normalize";
+import { remoteName } from "../../identity";
+
+// Bare `require` only exists under bun's ESM; node ESM needs an explicit
+// binding. tsx patches the module loader, so this require still loads the
+// plugin.dev.ts source.
+const require = createRequire(import.meta.url);
 
 export interface PluginInfo {
   name: string;
@@ -17,7 +23,7 @@ export function getPluginInfo(context: string): PluginInfo {
   return {
     name: pkg.name,
     version: pkg.version,
-    normalizedName: getNormalizedRemoteName(pkg.name),
+    normalizedName: remoteName(pkg.name),
     dependencies: pkg.dependencies || {},
     peerDependencies: pkg.peerDependencies || {},
   };

package/src/build/ui/factory.ts

@@ -0,0 +1,96 @@
+/**
+ * The core ui's rsbuild factory — the workspace-form counterpart of
+ * `createUiRsbuildConfig` (folder-form plugin uis). The config object the
+ * generated `.every-plugin/ui.rsbuild.config.generated.mjs` materializes:
+ * the APP_NAME/APP_ACCOUNT defines come from the authored config through
+ * `readAuthoredConfigInput` (everything-dev/config), which the generated
+ * file loads in the workspace's own module graph.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { CORE_UI_PLUGIN_KEY } from "../../ui/manifest/contract";
+import { createUiRsbuildConfig } from "./rsbuild-config";
+
+/**
+ * The platform skill family ships inside the framework packages' npm tarballs
+ * (`files: ["skills"]`), so resolving them from `node_modules` gives the core
+ * ui the same copies in the parent workspace (pnpm symlinks) and every
+ * generated child repo (published tarball). Served at `/skills/<pkg>/<skill>`.
+ */
+const SKILL_PACKAGES = ["everything-dev", "every-plugin", "better-near-auth"] as const;
+
+export function platformSkillCopies(workspaceRoot: string): Array<{
+  from: string;
+  to: string;
+  globOptions: { ignore: string[] };
+}> {
+  return SKILL_PACKAGES.flatMap((name) => {
+    const from = path.join(workspaceRoot, "node_modules", name, "skills");
+    return fs.existsSync(from)
+      ? [
+          {
+            from,
+            to: `./skills/${name}`,
+            globOptions: { ignore: ["**/_artifacts/**"] },
+          },
+        ]
+      : [];
+  });
+}
+
+export interface CoreUiRsbuildConfigInput {
+  /** Authored config domain — stamped as `import.meta.env.APP_NAME`. */
+  domain?: string;
+  /** Authored config account — stamped as `import.meta.env.APP_ACCOUNT`. */
+  account?: string;
+}
+
+/**
+ * The core ui's MF build surface — entry points and the declared exposes
+ * (ADR 0008 §2). Entries and the bootstrap exposes resolve to GENERATED
+ * stubs (ADR 0023); only surfaces with consumers are declared: the browser
+ * bootstrap, the shared component barrel, the SSR router module, the
+ * composition engine, and the generated route config.
+ */
+export const CORE_UI_WEB_ENTRY = "./src/entry.gen.ts";
+
+export const CORE_UI_WEB_EXPOSES: Record<string, string> = {
+  "./Hydrate": "./src/hydrate.gen.tsx",
+  "./components": "./src/components/index.ts",
+};
+
+export const CORE_UI_NODE_ENTRY = "./src/router.server.gen.tsx";
+
+export const CORE_UI_NODE_EXPOSES: Record<string, string> = {
+  "./Router": "./src/router.server.gen.tsx",
+  "./compose": "./src/compose.gen.ts",
+  "./routeConfig": "./src/routeConfig.gen.ts",
+};
+
+export function createCoreUiRsbuildConfig({ domain, account }: CoreUiRsbuildConfigInput = {}) {
+  const workspaceRoot = process.cwd();
+  const pkg = JSON.parse(fs.readFileSync(path.join(workspaceRoot, "package.json"), "utf-8")) as {
+    name: string;
+  };
+
+  return createUiRsbuildConfig({
+    workspaceRoot,
+    pkg,
+    role: "provider",
+    manifestName: CORE_UI_PLUGIN_KEY,
+    devPort: 3003,
+    webEntry: CORE_UI_WEB_ENTRY,
+    webExposes: CORE_UI_WEB_EXPOSES,
+    nodeEntry: CORE_UI_NODE_ENTRY,
+    nodeExposes: CORE_UI_NODE_EXPOSES,
+    copy: [
+      { from: path.join(workspaceRoot, "public"), to: "./" },
+      ...platformSkillCopies(workspaceRoot),
+    ],
+    define: {
+      "import.meta.env.APP_NAME": JSON.stringify(domain),
+      "import.meta.env.APP_ACCOUNT": JSON.stringify(account),
+    },
+  });
+}