@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/src/build-config/build-environment.ts

@@ -0,0 +1,160 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import type { URL } from 'node:url';
+
+const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
+const EFFECT_TSGO_BIN = 'effect-tsgo';
+const EFFECT_TSGO_RESOLUTION_ERROR =
+  'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN.';
+const executableEffectTsgoCompilers = new Map<string, string>();
+
+type PackageJson = {
+  bin?: Record<string, string> | string;
+};
+
+function resolveEffectTsgoCli(from: string | URL): string {
+  const projectRequire = createRequire(from);
+  const packageJsonPath = projectRequire.resolve(
+    `${EFFECT_TSGO_PACKAGE}/package.json`,
+  );
+  const packageJson = JSON.parse(
+    readFileSync(packageJsonPath, 'utf-8'),
+  ) as PackageJson;
+  const bin =
+    typeof packageJson.bin === 'string'
+      ? packageJson.bin
+      : packageJson.bin?.[EFFECT_TSGO_BIN];
+
+  if (!bin) {
+    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+  }
+
+  return resolve(dirname(packageJsonPath), bin);
+}
+
+function resolveExecutableEffectTsgoCompiler(compilerPath: string): string {
+  if (process.platform === 'win32') {
+    return compilerPath;
+  }
+
+  const sourcePath = realpathSync(compilerPath);
+  const source = lstatSync(sourcePath);
+  if (!source.isFile()) {
+    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+  }
+
+  try {
+    accessSync(sourcePath, constants.X_OK);
+    return compilerPath;
+  } catch {
+    // npm currently publishes Effect TS-Go's native Unix files without an
+    // execute bit. Keep node_modules immutable and materialize a private copy.
+  }
+
+  const cachedCompiler = executableEffectTsgoCompilers.get(sourcePath);
+  if (cachedCompiler) {
+    try {
+      accessSync(cachedCompiler, constants.X_OK);
+      return cachedCompiler;
+    } catch {
+      executableEffectTsgoCompilers.delete(sourcePath);
+    }
+  }
+
+  const compilerBytes = readFileSync(sourcePath);
+  const compilerDigest = createHash('sha256')
+    .update(compilerBytes)
+    .digest('hex');
+  const compilerDirectory = join(
+    tmpdir(),
+    'modern-js',
+    'effect-tsgo',
+    compilerDigest,
+  );
+  mkdirSync(compilerDirectory, { recursive: true, mode: 0o700 });
+  const executableCompiler = join(compilerDirectory, basename(sourcePath));
+  try {
+    accessSync(executableCompiler, constants.X_OK);
+  } catch {
+    const temporaryCompiler = join(
+      compilerDirectory,
+      `.${basename(sourcePath)}.${process.pid}.tmp`,
+    );
+    rmSync(temporaryCompiler, { force: true });
+    try {
+      writeFileSync(temporaryCompiler, compilerBytes, {
+        flag: 'wx',
+        mode: 0o700,
+      });
+      chmodSync(temporaryCompiler, 0o700);
+      renameSync(temporaryCompiler, executableCompiler);
+    } finally {
+      rmSync(temporaryCompiler, { force: true });
+    }
+  }
+  accessSync(executableCompiler, constants.X_OK);
+  executableEffectTsgoCompilers.set(sourcePath, executableCompiler);
+  return executableCompiler;
+}
+
+/**
+ * Reads an environment variable while keeping generated build configs free of
+ * direct process access.
+ */
+export function getBuildConfigEnvironment(name: string): string | undefined {
+  return process.env[name];
+}
+
+export type ResolveEffectTsgoCompilerOptions = {
+  /** Module URL or absolute filename used to resolve the consumer's compiler. */
+  from: string | URL;
+};
+
+/**
+ * Resolves the Effect TS-Go executable used by Module Federation DTS builds.
+ */
+export function resolveEffectTsgoCompiler(
+  options: ResolveEffectTsgoCompilerOptions,
+): string {
+  const configuredCompiler =
+    getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
+
+  if (configuredCompiler) {
+    try {
+      return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+    } catch {
+      throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    }
+  }
+
+  try {
+    const compiler = execFileSync(
+      process.execPath,
+      [resolveEffectTsgoCli(options.from), 'get-exe-path'],
+      { encoding: 'utf-8' },
+    ).trim();
+
+    if (compiler) {
+      return resolveExecutableEffectTsgoCompiler(compiler);
+    }
+  } catch {
+    // Use one stable error for package, platform-binary, and CLI failures.
+  }
+
+  throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+}

package/src/build-config/precompress/plugin.ts

@@ -0,0 +1,140 @@
+import { constants as zlibConstants } from 'node:zlib';
+import type { RsbuildPlugin } from '@rsbuild/core';
+import CompressionPlugin from 'compression-webpack-plugin';
+import type { PrecompressConfig } from './types';
+
+export type { PrecompressCodecOptions, PrecompressConfig } from './types';
+
+type CompressionPluginOptions = NonNullable<
+  ConstructorParameters<typeof CompressionPlugin>[0]
+>;
+
+const DEFAULT_PRECOMPRESS_TEST = /\.(js|mjs|cjs|css|html|svg|json|map)$/i;
+const DEFAULT_PRECOMPRESS_THRESHOLD = 10 * 1024;
+const DEFAULT_PRECOMPRESS_MIN_RATIO = 0.8;
+
+const createDefaultGzipOptions = (): CompressionPluginOptions => ({
+  algorithm: 'gzip',
+  filename: '[path][base].gz',
+  test: DEFAULT_PRECOMPRESS_TEST,
+  threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+  minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+  compressionOptions: {
+    level: 6,
+  },
+});
+
+const createDefaultBrotliOptions = (): CompressionPluginOptions => ({
+  algorithm: 'brotliCompress',
+  filename: '[path][base].br',
+  test: DEFAULT_PRECOMPRESS_TEST,
+  threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+  minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+  compressionOptions: {
+    params: {
+      [zlibConstants.BROTLI_PARAM_QUALITY]: 9,
+    },
+  },
+});
+
+const mergeCompressionOptions = (
+  base: CompressionPluginOptions,
+  next: Partial<CompressionPluginOptions>,
+): CompressionPluginOptions => {
+  const merged = {
+    ...base,
+    ...next,
+  };
+
+  if (base.compressionOptions || next.compressionOptions) {
+    const baseCompressionOptions = base.compressionOptions as
+      | Record<string, unknown>
+      | undefined;
+    const nextCompressionOptions = next.compressionOptions as
+      | Record<string, unknown>
+      | undefined;
+    const mergedCompressionOptions = {
+      ...baseCompressionOptions,
+      ...nextCompressionOptions,
+    };
+
+    if (baseCompressionOptions?.params || nextCompressionOptions?.params) {
+      mergedCompressionOptions.params = {
+        ...(baseCompressionOptions?.params as Record<string, unknown>),
+        ...(nextCompressionOptions?.params as Record<string, unknown>),
+      };
+    }
+
+    merged.compressionOptions = mergedCompressionOptions;
+  }
+
+  return merged;
+};
+
+const resolveCodecOptions = (
+  codecConfig: PrecompressConfig['gzip'] | PrecompressConfig['brotli'],
+  createDefaultOptions: () => CompressionPluginOptions,
+): CompressionPluginOptions | null => {
+  if (codecConfig === false) {
+    return null;
+  }
+
+  if (codecConfig === undefined || codecConfig === true) {
+    return createDefaultOptions();
+  }
+
+  return mergeCompressionOptions(createDefaultOptions(), codecConfig);
+};
+
+const resolvePrecompressConfig = (
+  precompress: boolean | PrecompressConfig | undefined,
+): PrecompressConfig | false => {
+  if (precompress === false || precompress === undefined) {
+    return false;
+  }
+
+  if (precompress === true) {
+    return {};
+  }
+
+  return precompress;
+};
+
+export const builderPluginAdapterPrecompress = (
+  precompress: boolean | PrecompressConfig | undefined,
+): RsbuildPlugin => ({
+  name: 'builder-plugin-adapter-modern-precompress',
+
+  setup(api) {
+    api.modifyBundlerChain((chain, { isProd, target }) => {
+      if (!isProd || target !== 'web') {
+        return;
+      }
+
+      const precompressConfig = resolvePrecompressConfig(precompress);
+      if (precompressConfig === false) {
+        return;
+      }
+
+      const gzipOptions = resolveCodecOptions(
+        precompressConfig.gzip,
+        createDefaultGzipOptions,
+      );
+      if (gzipOptions) {
+        chain
+          .plugin('modern-precompress-gzip')
+          .use(CompressionPlugin, [gzipOptions]);
+      }
+
+      const brotliOptions = resolveCodecOptions(
+        precompressConfig.brotli,
+        createDefaultBrotliOptions,
+      );
+      if (brotliOptions) {
+        chain
+          .plugin('modern-precompress-brotli')
+          .use(CompressionPlugin, [brotliOptions]);
+      }
+    });
+  },
+});

package/src/build-config/precompress/types.ts

@@ -0,0 +1,26 @@
+import type CompressionPlugin from 'compression-webpack-plugin';
+
+type CompressionPluginOptions = NonNullable<
+  ConstructorParameters<typeof CompressionPlugin>[0]
+>;
+
+export type PrecompressCodecOptions =
+  | boolean
+  | Partial<CompressionPluginOptions>;
+
+export interface PrecompressConfig {
+  /**
+   * Configure gzip precompression options.
+   * `true` means using default options.
+   * `false` means disabling gzip precompression.
+   * @default true
+   */
+  gzip?: PrecompressCodecOptions;
+  /**
+   * Configure brotli precompression options.
+   * `true` means using default options.
+   * `false` means disabling brotli precompression.
+   * @default true
+   */
+  brotli?: PrecompressCodecOptions;
+}

package/src/build-config/public.ts

@@ -0,0 +1,5 @@
+export type { ResolveEffectTsgoCompilerOptions } from './build-environment';
+export {
+  getBuildConfigEnvironment,
+  resolveEffectTsgoCompiler,
+} from './build-environment';

package/src/build-config/remote-address.ts

@@ -0,0 +1,33 @@
+import {
+  type BrowserManifestAddressOptions,
+  resolveBrowserManifestAddress,
+} from '@modern-js/surface-resolution';
+import { resolveDeployTarget } from '../deploy-output/target';
+import { getBuildConfigEnvironment } from './build-environment';
+
+/** Adapt build environment leases and MF's name@URL syntax to discovery policy. */
+export function createRemoteManifestUrl(
+  options: BrowserManifestAddressOptions,
+): string {
+  const env: Record<string, string | undefined> = {
+    ...Object.fromEntries(
+      [
+        options.manifestEnv,
+        options.publicUrlEnv,
+        'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
+      ].map(name => [name, getBuildConfigEnvironment(name)]),
+    ),
+    MODERNJS_DEPLOY: resolveDeployTarget().target,
+  };
+  const address = resolveBrowserManifestAddress(
+    env,
+    options,
+    getBuildConfigEnvironment('NODE_ENV') ?? 'production',
+  );
+  if (!address.ok)
+    throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+  return (
+    env[options.manifestEnv]?.trim() ||
+    `${options.mfName}@${address.manifestUrl}`
+  );
+}

package/src/cloudflare/artifacts.ts

@@ -1,9 +1,11 @@
 import path from 'node:path';
 import { fs as fse } from '@modern-js/utils';
-import type {
-  CloudflareWorkerArtifactConfig,
-  CloudflareWorkerPublicAssetConfig,
-} from '../config';
+import type { CloudflareWorkerArtifactConfig } from '../config';
+import {
+  CLOUDFLARE_PUBLIC_ASSET_SCOPE,
+  normalizeDeclaredPublicAssets,
+  stageDeclaredPublicAssets,
+} from '../deploy-output/public-assets';
 import {
   RESERVED_ARTIFACT_DESTINATION_DIRECTORIES,
   RESERVED_ARTIFACT_DESTINATION_FILES,
@@ -54,34 +56,12 @@ export const getCloudflareArtifacts = (modernConfig: CloudflareModernConfig) =>
     normalizeCloudflareArtifact,
   );
 
-const normalizeCloudflarePublicAsset = (
-  asset: CloudflareWorkerPublicAssetConfig,
-  index: number,
-) => {
-  const from = normalizeRelativePath(
-    asset.from,
-    `deploy.worker.publicAssets[${index}].from`,
-    'app root',
-  );
-  const to = normalizeRelativePath(
-    asset.to,
-    `deploy.worker.publicAssets[${index}].to`,
-    'Cloudflare public output',
-    { allowRoot: true },
-  );
-
-  return {
-    from,
-    to,
-    index,
-  };
-};
-
 export const getCloudflarePublicAssets = (
   modernConfig: CloudflareModernConfig,
 ) =>
-  (modernConfig.deploy?.worker?.publicAssets ?? []).map(
-    normalizeCloudflarePublicAsset,
+  normalizeDeclaredPublicAssets(
+    modernConfig.deploy?.worker?.publicAssets,
+    CLOUDFLARE_PUBLIC_ASSET_SCOPE,
   );
 
 export const copyCloudflareArtifacts = async (
@@ -102,23 +82,22 @@ export const copyCloudflareArtifacts = async (
   }
 };
 
+/**
+ * Stage `deploy.worker.publicAssets` into Worker Static Assets.
+ *
+ * @returns the staged files relative to the Cloudflare output root.
+ */
 export const copyCloudflarePublicAssets = async (
   appDirectory: string,
-  publicDirectory: string,
+  outputDirectory: string,
   publicAssets: ReturnType<typeof getCloudflarePublicAssets>,
-) => {
-  for (const asset of publicAssets) {
-    const sourcePath = path.join(appDirectory, asset.from);
-
-    if (!(await fse.pathExists(sourcePath))) {
-      throw new Error(
-        `deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`,
-      );
-    }
-
-    await fse.copy(sourcePath, path.join(publicDirectory, asset.to));
-  }
-};
+) =>
+  stageDeclaredPublicAssets({
+    appDirectory,
+    outputDirectory,
+    assets: publicAssets,
+    scope: CLOUDFLARE_PUBLIC_ASSET_SCOPE,
+  });
 
 export const copyCloudflareD1Migrations = async (
   appDirectory: string,

package/src/cloudflare/constants.ts

@@ -34,7 +34,7 @@ export const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_
 export const BFF_EFFECT_WORKER_DISPATCHER_EXPORT =
   '__modern_create_effect_bff_dispatcher';
 export const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE =
-  'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
+  'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/bff-effect/effect-edge instead of lambda/Hono server helpers.';
 export const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
 export const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 export const REQUIRED_COMPATIBILITY_FLAGS =

package/src/cloudflare/delivery-unit.ts

@@ -1,17 +1,16 @@
 import path from 'node:path';
-import { fs as fse } from '@modern-js/utils';
 import {
   type DeliveryUnitIdentity,
   isUltramodernBuildArtifact,
   nonEmptyString,
   toDeliveryUnitIdentity,
   ULTRAMODERN_BUILD_ARTIFACT_PATH,
-  ULTRAMODERN_BUILD_MODULE_PATH,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
+import { fs as fse } from '@modern-js/utils';
 import { resolveUltramodernReleaseIdentity } from '../release-identity';
 import { isRecord } from './utils';
 
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const TOPOLOGY_PATH = 'topology/reference-topology.json';
 
 export type DeliveryUnitStamp = DeliveryUnitIdentity & {
   surfaces: {
@@ -20,7 +19,7 @@ export type DeliveryUnitStamp = DeliveryUnitIdentity & {
   };
 };
 
-type CompactAppResolution = {
+type TopologyAppResolution = {
   app?: Record<string, unknown>;
   workspaceRoot: string;
 };
@@ -31,7 +30,7 @@ const findWorkspaceRoot = async (
   let current = path.resolve(appDirectory);
 
   for (;;) {
-    if (await fse.pathExists(path.join(current, COMPACT_CONFIG_PATH))) {
+    if (await fse.pathExists(path.join(current, TOPOLOGY_PATH))) {
       return current;
     }
 
@@ -61,34 +60,32 @@ const stampReleaseIdentity = (
   };
 };
 
-const resolveCompactApp = async (
+const resolveTopologyApp = async (
   appDirectory: string,
-): Promise<CompactAppResolution | undefined> => {
+): Promise<TopologyAppResolution | undefined> => {
   const workspaceRoot = await findWorkspaceRoot(appDirectory);
   if (!workspaceRoot) {
     return undefined;
   }
 
-  let compactConfig: unknown;
-  try {
-    compactConfig = await fse.readJSON(
-      path.join(workspaceRoot, COMPACT_CONFIG_PATH),
+  const topology: unknown = await fse.readJSON(
+    path.join(workspaceRoot, TOPOLOGY_PATH),
+  );
+  if (
+    !isRecord(topology) ||
+    !isRecord(topology.shell) ||
+    !Array.isArray(topology.verticals) ||
+    (topology.shells !== undefined && !Array.isArray(topology.shells))
+  ) {
+    throw new Error(
+      '[cloudflare-delivery-unit] Invalid declared reference topology.',
     );
-  } catch {
-    return { workspaceRoot };
-  }
-
-  if (!isRecord(compactConfig)) {
-    return { workspaceRoot };
-  }
-
-  const topology = isRecord(compactConfig.topology)
-    ? compactConfig.topology
-    : undefined;
-  const apps = Array.isArray(topology?.apps) ? topology.apps : undefined;
-  if (!apps) {
-    return { app: compactConfig, workspaceRoot };
   }
+  const apps = [
+    topology.shell,
+    ...topology.verticals,
+    ...(Array.isArray(topology.shells) ? topology.shells : []),
+  ];
 
   const resolvedAppDirectory = path.resolve(appDirectory);
   const app = apps.find(candidate => {
@@ -102,8 +99,13 @@ const resolveCompactApp = async (
         resolvedAppDirectory
     );
   });
+  if (!isRecord(app)) {
+    throw new Error(
+      `[cloudflare-delivery-unit] ${appDirectory} is missing from the declared reference topology.`,
+    );
+  }
   return {
-    ...(isRecord(app) ? { app } : {}),
+    app,
     workspaceRoot,
   };
 };
@@ -127,28 +129,31 @@ const createDeliveryUnitStamp = (
 
 /**
  * Resolve the delivery-unit record declared for this app by the workspace
- * compact config (`.modernjs/ultramodern.json`). This is the topology source
+ * reference topology. This is the topology source
  * of truth the Cloudflare worker snapshot is verified against.
  */
 export const resolveTopologyDeliveryUnit = async (
   appDirectory: string,
 ): Promise<DeliveryUnitStamp | undefined> => {
-  const resolved = await resolveCompactApp(appDirectory);
+  const resolved = await resolveTopologyApp(appDirectory);
   if (!resolved?.app) {
     return undefined;
   }
   const identity = toDeliveryUnitIdentity(resolved.app.deliveryUnit);
-  return identity
-    ? createDeliveryUnitStamp(
-        stampReleaseIdentity(identity, resolved.workspaceRoot),
-        resolved.app,
-      )
-    : undefined;
+  if (!identity) {
+    throw new Error(
+      '[cloudflare-delivery-unit] Declared app is missing a valid delivery-unit identity.',
+    );
+  }
+  return createDeliveryUnitStamp(
+    stampReleaseIdentity(identity, resolved.workspaceRoot),
+    resolved.app,
+  );
 };
 
 /**
  * Resolve the delivery-unit identity actually bundled into the worker by
- * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * reading the generated `shared/ultramodern-build.json` artifact. This is the
  * worker snapshot / declared surface source that gets stamped into the manifest.
  */
 export const resolveWorkerDeliveryUnitStamp = async (
@@ -158,10 +163,6 @@ export const resolveWorkerDeliveryUnitStamp = async (
     appDirectory,
     ULTRAMODERN_BUILD_ARTIFACT_PATH,
   );
-  const buildModulePath = path.join(
-    appDirectory,
-    ULTRAMODERN_BUILD_MODULE_PATH,
-  );
   let identity: DeliveryUnitIdentity | undefined;
 
   if (await fse.pathExists(buildArtifactPath)) {
@@ -170,24 +171,12 @@ export const resolveWorkerDeliveryUnitStamp = async (
       return undefined;
     }
     identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
-  } else if (await fse.pathExists(buildModulePath)) {
-    console.warn(
-      `[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`,
-    );
-    const source = await fse.readFile(buildModulePath, 'utf8');
-    identity = toDeliveryUnitIdentity({
-      buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
-      unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
-      sourceRevision: source.match(
-        /\bsourceRevision:\s*['"]([^'"]+)['"]/u,
-      )?.[1],
-    });
   }
 
   if (!identity) {
     return undefined;
   }
-  const resolved = await resolveCompactApp(appDirectory);
+  const resolved = await resolveTopologyApp(appDirectory);
   if (resolved) {
     identity = stampReleaseIdentity(identity, resolved.workspaceRoot);
   }