@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/src/deploy-output/plugin.ts

@@ -0,0 +1,49 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { preserveNpmAliases, readPackageIdentity } from './npmAliases';
+import {
+  type DeployOutputConfig,
+  resolveDeployTarget as defaultResolveDeployTarget,
+} from './target';
+
+export interface DeployOutputPluginApi {
+  getAppContext(): { appDirectory: string; metaName: string };
+  getNormalizedConfig(): DeployOutputConfig;
+  onAfterDeploy(handler: () => Promise<void>): void;
+}
+
+export const createDeployOutputAliasesPlugin = ({
+  resolveDeployTarget = defaultResolveDeployTarget,
+}: {
+  resolveDeployTarget?: (config: DeployOutputConfig) => string;
+} = {}) => ({
+  name: '@modern-js/deploy-output-aliases',
+  setup(api: DeployOutputPluginApi) {
+    api.onAfterDeploy(async () => {
+      const { appDirectory, metaName } = api.getAppContext();
+      const config = api.getNormalizedConfig();
+      if (
+        (metaName !== 'modern-js' &&
+          !config.deploy?.target &&
+          !process.env.MODERNJS_DEPLOY) ||
+        resolveDeployTarget(config) !== 'node'
+      ) {
+        return;
+      }
+
+      const entry = createRequire(__filename).resolve('@modern-js/prod-server');
+      const identity = await readPackageIdentity(entry);
+      await preserveNpmAliases({
+        appDirectory,
+        outputDirectory: path.join(appDirectory, '.output'),
+        implicitAliases: [
+          {
+            aliasName: '@modern-js/prod-server',
+            targetName: identity.name,
+            targetVersion: identity.version,
+          },
+        ],
+      });
+    });
+  },
+});

package/src/deploy-output/target.ts

@@ -0,0 +1,23 @@
+import { provider } from 'std-env';
+
+export interface DeployOutputConfig {
+  deploy?: { target?: string };
+}
+
+const providerDeployTargets: Partial<Record<string, string>> = {
+  vercel: 'vercel',
+  netlify: 'netlify',
+  cloudflare: 'cloudflare',
+  cloudflare_pages: 'cloudflare',
+  cloudflare_workers: 'cloudflare',
+};
+
+export const resolveDeployTarget = (
+  config: DeployOutputConfig,
+  envDeployTarget = process.env.MODERNJS_DEPLOY,
+  detectedProvider = provider,
+): string =>
+  config.deploy?.target ||
+  envDeployTarget ||
+  (detectedProvider ? providerDeployTargets[detectedProvider] : undefined) ||
+  'node';

package/src/native-type-checker.ts

@@ -0,0 +1,183 @@
+import { execFile } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { refreshTsgoCheckerConfig } from '@modern-js/builder';
+import type { Rspack, RspackChain } from '@rsbuild/core';
+
+const execute = promisify(execFile);
+const name = 'UltramodernNativeTypeChecker';
+
+// Windows file events expand 8.3 aliases; register the same native path spelling.
+// A path that does not exist yet (a project tsconfig mid-edit) cannot be
+// realpathed; it is registered as spelled so its return still triggers a build.
+const watchDependencyPath = (file: string): string => {
+  if (process.platform !== 'win32') return file;
+  try {
+    return realpathSync.native(file);
+  } catch {
+    return file;
+  }
+};
+
+export class UltramodernNativeTypeChecker {
+  constructor(
+    private readonly options: {
+      compiler: () => string;
+      configFile: string;
+      build: boolean;
+    },
+  ) {}
+
+  async check(): Promise<void> {
+    const { configFile, build } = this.options;
+    if (!build) {
+      const config = JSON.parse(
+        await this.run(['--showConfig', '--project', configFile]),
+      ) as { references?: { path: string }[] };
+      // Project mode consumes referenced declarations but never builds them.
+      // Prepare only the references using their own emit contracts, then keep
+      // the app itself in no-emit mode. This also refreshes stale declarations.
+      if (config.references?.length) {
+        await this.run([
+          '--build',
+          ...config.references.map(reference =>
+            path.resolve(path.dirname(configFile), reference.path),
+          ),
+          '--stopBuildOnErrors',
+          '--pretty',
+          'false',
+        ]);
+      }
+    }
+    const args = build
+      ? ['--build', configFile, '--stopBuildOnErrors']
+      : ['--project', configFile, '--noEmit'];
+    await this.run([...args, '--pretty', 'false']);
+  }
+
+  private async run(args: string[]): Promise<string> {
+    try {
+      const result = await execute(this.options.compiler(), args, {
+        cwd: path.dirname(this.options.configFile),
+        maxBuffer: 16 * 1024 * 1024,
+      });
+      return result.stdout;
+    } catch (cause) {
+      const output = cause as { stdout?: string; stderr?: string };
+      const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+      throw new Error(
+        `${name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`,
+        { cause },
+      );
+    }
+  }
+
+  private async watchInputs(): Promise<{
+    inputs: Set<string>;
+    missing: Set<string>;
+  }> {
+    const inputs = new Set<string>();
+    const missing = new Set<string>();
+    const projects = [this.options.configFile];
+    const visited = new Set<string>();
+    for (const configFile of projects) {
+      if (visited.has(configFile)) continue;
+      visited.add(configFile);
+      // Registered before it is parsed: a referenced config that is absent or
+      // unparsable right now must still be watched, or creating or repairing
+      // it never re-triggers the compilation. `check()` reports the error.
+      inputs.add(configFile);
+      if (!existsSync(configFile)) {
+        missing.add(configFile);
+        continue;
+      }
+      let config: { files?: string[]; references?: { path: string }[] };
+      try {
+        config = JSON.parse(
+          await this.run(['--showConfig', '--project', configFile]),
+        );
+      } catch {
+        continue;
+      }
+      const directory = path.dirname(configFile);
+      for (const file of config.files ?? [])
+        inputs.add(path.resolve(directory, file));
+      for (const reference of config.references ?? []) {
+        const target = path.resolve(directory, reference.path);
+        projects.push(
+          path.extname(target) === '.json'
+            ? target
+            : path.join(target, 'tsconfig.json'),
+        );
+      }
+    }
+    return { inputs, missing };
+  }
+
+  apply(compiler: Rspack.Compiler): void {
+    compiler.hooks.thisCompilation.tap(name, compilation => {
+      compilation.hooks.processAssets.tapPromise(name, async () => {
+        try {
+          compilation.fileDependencies.add(
+            watchDependencyPath(this.options.configFile),
+          );
+          // A generated checker config restates values TypeScript does not
+          // inherit through `extends` (project references above all). Rebuild
+          // it from the project's own tsconfig before every check, and watch
+          // that tsconfig, so an edit during `modern dev` reaches the next
+          // compilation instead of the next restart.
+          const projectConfigFile = refreshTsgoCheckerConfig(
+            this.options.configFile,
+          );
+          if (projectConfigFile) {
+            const watched = watchDependencyPath(projectConfigFile);
+            compilation.fileDependencies.add(watched);
+            // Absent mid-edit: a missing dependency makes its (re)appearance
+            // a rebuild trigger, so the dev server recovers on its own.
+            if (!existsSync(projectConfigFile)) {
+              compilation.missingDependencies.add(watched);
+            }
+          }
+          const { inputs, missing } = await this.watchInputs();
+          for (const file of inputs)
+            compilation.fileDependencies.add(watchDependencyPath(file));
+          for (const file of missing)
+            compilation.missingDependencies.add(watchDependencyPath(file));
+          await this.check();
+        } catch (cause) {
+          compilation.errors.push(
+            new Error(cause instanceof Error ? cause.message : String(cause), {
+              cause,
+            }),
+          );
+        }
+      });
+    });
+  }
+}
+
+/** Preserve project-reference emit contracts in the native Effect compiler. */
+export function configureUltramodernTypeChecker(
+  chain: RspackChain,
+  pluginId: string,
+  resolveCompiler: (configFile: string) => string,
+): void {
+  if (!chain.plugins.has(pluginId)) return;
+  const options = chain.plugin(pluginId).get('args')?.[0] as
+    | { typescript?: { configFile?: string; build?: boolean; tsgo?: boolean } }
+    | undefined;
+  const typescript = options?.typescript;
+  if (typescript?.tsgo === false) return;
+  if (!typescript?.configFile) {
+    throw new Error(`${name} requires the configured TypeScript project.`);
+  }
+  const configFile = path.resolve(typescript.configFile);
+  chain.plugin(pluginId).use(UltramodernNativeTypeChecker, [
+    {
+      build: typescript.build === true,
+      compiler: () => resolveCompiler(configFile),
+      configFile,
+    },
+  ]);
+}

package/src/policy-defaults.ts

@@ -0,0 +1,127 @@
+import {
+  collectRuntimePackageModuleDirectories,
+  createRuntimePackageResolutionPlugin,
+} from './runtime-package-resolution';
+
+/**
+ * The fork's renderer policy (head rendering, HTML template assembly and asset
+ * ordering) and server policy (localised loaders, error responses, telemetry,
+ * module-federation CSS and asset cache headers, static serving) are the
+ * default behaviour of an UltraModern.js app.
+ *
+ * They live in their own packages so they can also be composed explicitly, but
+ * a plain `appTools()` app gets them without opting in — that is what this fork
+ * has always done. Pass `appTools({ rendererExtensions: false })` or
+ * `appTools({ serverExtensions: false })` to run without them.
+ */
+export const RENDERER_EXTENSIONS_PACKAGE =
+  '@modern-js/runtime-renderer-extensions';
+
+export const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+
+export const SERVER_EXTENSIONS_PLUGIN_NAME =
+  '@modern-js/app-tools/server-plugin';
+
+export interface PolicyDefaultsOptions {
+  /** Default `true`. Set to `false` to drop the fork's renderer policy. */
+  rendererExtensions?: boolean;
+  /** Default `true`. Set to `false` to drop the fork's server policy. */
+  serverExtensions?: boolean;
+}
+
+type RuntimePluginDescriptor = {
+  name?: string;
+  path: string;
+  config?: unknown;
+};
+
+type ServerPluginDescriptor = { name: string };
+
+/**
+ * The subset of the CLI plugin API these defaults use. Typed structurally, and
+ * loosely at the hook boundary, so this package stays free of a dependency on
+ * the solution that consumes it — which depends on this one.
+ */
+export interface PolicyDefaultsPluginApi {
+  _internalRuntimePlugins(fn: (input: any) => any): void;
+  _internalServerPlugins(fn: (input: any) => any): void;
+  modifyResolvedConfig(fn: (config: any) => any): void;
+}
+
+type RuntimePluginsInput = {
+  entrypoint: unknown;
+  plugins: RuntimePluginDescriptor[];
+};
+
+type ServerPluginsInput = { plugins: ServerPluginDescriptor[] };
+
+export const POLICY_DEFAULTS_PLUGIN_NAME =
+  '@modern-js/ultramodern-policy-defaults';
+
+/** Registers the fork's default renderer and server policy. */
+export const applyPolicyDefaults = (
+  api: PolicyDefaultsPluginApi,
+  options: PolicyDefaultsOptions = {},
+): void => {
+  if (options.rendererExtensions !== false) {
+    api._internalRuntimePlugins(
+      ({ entrypoint, plugins }: RuntimePluginsInput) => {
+        // An explicit composition (`ultramodernAppTools()`) may already have
+        // registered it; the descriptor list must stay free of duplicates.
+        if (
+          !plugins.some(plugin => plugin.path === RENDERER_EXTENSIONS_PACKAGE)
+        ) {
+          plugins.push({
+            name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+            path: RENDERER_EXTENSIONS_PACKAGE,
+            config: {},
+          });
+        }
+        return { entrypoint, plugins };
+      },
+    );
+
+    const moduleDirectories = collectRuntimePackageModuleDirectories(
+      [RENDERER_EXTENSIONS_PACKAGE],
+      import.meta.url,
+    );
+    if (moduleDirectories.length > 0) {
+      api.modifyResolvedConfig(config => ({
+        ...config,
+        builderPlugins: [
+          ...(config.builderPlugins ?? []),
+          createRuntimePackageResolutionPlugin(moduleDirectories),
+        ],
+      }));
+    }
+  }
+
+  if (options.serverExtensions !== false) {
+    api._internalServerPlugins(({ plugins }: ServerPluginsInput) => {
+      if (
+        !plugins.some(plugin => plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)
+      ) {
+        plugins.push({ name: SERVER_EXTENSIONS_PLUGIN_NAME });
+      }
+      return { plugins };
+    });
+  }
+};
+
+/**
+ * The fork defaults as a CLI plugin.
+ *
+ * The descriptor this registers may land before the ones it wraps — CLI
+ * ordering cannot be constrained here without a cycle, because the plugins
+ * that emit those descriptors are themselves ordered after `appTools()`.
+ * Ordering is settled on the runtime side instead: `rendererHeadPlugin`
+ * declares the runtime plugins that run before it.
+ */
+export const createPolicyDefaultsPlugin = (
+  options: PolicyDefaultsOptions = {},
+) => ({
+  name: POLICY_DEFAULTS_PLUGIN_NAME,
+  setup(api: PolicyDefaultsPluginApi) {
+    applyPolicyDefaults(api, options);
+  },
+});

package/src/release-envelope/framework-output.ts

@@ -7,7 +7,7 @@ import {
   isUltramodernBuildArtifact,
   ULTRAMODERN_BUILD_ARTIFACT_FILE,
   type UltramodernBuildArtifact,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
 import {
   canonicalSerializeMicroVerticalReleaseEnvelope,
   createMicroVerticalReleaseEnvelope,
@@ -57,6 +57,111 @@ const collectNestedStrings = (value: unknown, key: string): string[] => {
   ]);
 };
 
+// Empty native MF producers emit no remote entry or exposed execution assets.
+// Only their routeAssets declarations may supply the missing browser evidence.
+const emptyProducerRouteModules = async (
+  distDirectory: string,
+  files: string[],
+  manifest: unknown,
+  manifestLogicalPath: string,
+): Promise<string[]> => {
+  if (
+    !isRecord(manifest) ||
+    !Array.isArray(manifest.exposes) ||
+    manifest.exposes.length !== 0 ||
+    !Array.isArray(manifest.remotes) ||
+    manifest.remotes.length !== 0 ||
+    !isRecord(manifest.metaData) ||
+    !isRecord(manifest.metaData.remoteEntry) ||
+    manifest.metaData.remoteEntry.name !== '' ||
+    manifest.metaData.remoteEntry.path !== '' ||
+    manifest.metaData.remoteEntry.type !== 'global'
+  ) {
+    return [];
+  }
+  const publicPath = manifest.metaData.publicPath;
+  // Reject encoded/ambiguous paths before URL parsing can normalize traversal.
+  const safeReference = (value: unknown): value is string =>
+    typeof value === 'string' &&
+    value.length > 0 &&
+    !/[\\\\%?#\s]/u.test(value) &&
+    !value.split('/').some(segment => segment === '.' || segment === '..');
+  if (!safeReference(publicPath)) {
+    return [];
+  }
+  const absoluteBase = /^https?:\/\//u.test(publicPath);
+  if (
+    publicPath !== 'auto' &&
+    (!publicPath.endsWith('/') ||
+      (!absoluteBase &&
+        (!publicPath.startsWith('/') || publicPath.startsWith('//'))))
+  ) {
+    return [];
+  }
+  if (absoluteBase) {
+    const base = new URL(publicPath);
+    if (base.username || base.password || base.href !== publicPath) {
+      return [];
+    }
+  }
+  const directory = path.posix.dirname(manifestLogicalPath);
+  const routesManifest = await readJson(
+    path.join(distDirectory, directory, 'routes-manifest.json'),
+  );
+  if (!isRecord(routesManifest) || !isRecord(routesManifest.routeAssets)) {
+    return [];
+  }
+  const modules = new Set<string>();
+  for (const route of Object.values(routesManifest.routeAssets)) {
+    if (!isRecord(route) || !Array.isArray(route.assets)) {
+      return [];
+    }
+    for (const reference of route.assets) {
+      if (!safeReference(reference) || reference.startsWith('//')) {
+        return [];
+      }
+      let relative = reference;
+      if (/^https?:\/\//u.test(reference)) {
+        if (!absoluteBase || !reference.startsWith(publicPath)) {
+          return [];
+        }
+        relative = reference.slice(publicPath.length);
+      } else if (reference.startsWith('/')) {
+        const prefix =
+          publicPath === 'auto'
+            ? '/'
+            : absoluteBase
+              ? new URL(publicPath).pathname
+              : publicPath;
+        if (!reference.startsWith(prefix)) {
+          return [];
+        }
+        relative = reference.slice(prefix.length);
+      }
+      // Never allow API, SSR, backend containers, or unrelated on-disk modules.
+      if (
+        !/^(?:static|html|public)\/[^:]+$/u.test(relative) ||
+        relative.includes('//')
+      ) {
+        return [];
+      }
+      const logicalPath = path.posix.join(directory, relative);
+      if (!files.includes(logicalPath)) {
+        return [];
+      }
+      // A browser-named symlink to server/private bytes is not browser evidence.
+      const assetStat = await fs.lstat(path.join(distDirectory, logicalPath));
+      if (!assetStat.isFile()) {
+        return [];
+      }
+      if (COMPILED_MODULE_PATTERN.test(logicalPath)) {
+        modules.add(logicalPath);
+      }
+    }
+  }
+  return [...modules];
+};
+
 const manifestReferencedClientModules = async (
   distDirectory: string,
   files: string[],
@@ -77,7 +182,7 @@ const manifestReferencedClientModules = async (
       .map(value => value.replace(/^https?:\/\/[^/]+/u, ''))
       .map(value => value.replace(/^\/+/u, '')),
   );
-  return files.filter(
+  const modules = files.filter(
     logicalPath =>
       COMPILED_MODULE_PATTERN.test(logicalPath) &&
       [...normalizedReferences].some(
@@ -87,6 +192,14 @@ const manifestReferencedClientModules = async (
           logicalPath.endsWith(`/${reference}`),
       ),
   );
+  return modules.length > 0
+    ? modules
+    : emptyProducerRouteModules(
+        distDirectory,
+        files,
+        manifest,
+        manifestLogicalPath,
+      );
 };
 
 const routeReferencedSsrModules = async (
@@ -209,7 +322,8 @@ const writeReleaseEnvelope = async (
 
 const readBuildArtifact = async (
   distDirectory: string,
-): Promise<UltramodernBuildArtifact> => {
+  requirePromotable = true,
+): Promise<UltramodernBuildArtifact | undefined> => {
   const artifactPath = path.join(
     distDirectory,
     ULTRAMODERN_BUILD_ARTIFACT_FILE,
@@ -221,6 +335,15 @@ const readBuildArtifact = async (
     );
   }
   if (artifact.deliveryUnit.sourceRevision === 'workspace') {
+    // `resolveUltramodernSourceRevision` deliberately labels a dirty or
+    // non-Git checkout `workspace` so development stays usable; only a
+    // promotion may not carry that identity. A plain `modern build` is the
+    // development path, so it skips the envelope instead of failing the
+    // build. The deploy path still asks for a promotable artifact, which is
+    // where the release gate belongs.
+    if (!requirePromotable) {
+      return undefined;
+    }
     throw new Error(
       '[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.',
     );
@@ -635,10 +758,12 @@ const pathExists = async (filePath: string) => {
 export const emitFrameworkMicroVerticalReleaseEnvelope = async ({
   apiOnly,
   distDirectory,
+  requirePromotable = true,
   target,
 }: {
   apiOnly: boolean;
   distDirectory: string;
+  requirePromotable?: boolean;
   target: MicroVerticalReleaseTarget;
 }): Promise<MicroVerticalReleaseEnvelope | undefined> => {
   if (apiOnly) {
@@ -665,7 +790,13 @@ export const emitFrameworkMicroVerticalReleaseEnvelope = async ({
     );
   }
 
-  const buildArtifact = await readBuildArtifact(distDirectory);
+  const buildArtifact = await readBuildArtifact(
+    distDirectory,
+    requirePromotable,
+  );
+  if (!buildArtifact) {
+    return undefined;
+  }
   const identity = {
     unitId: buildArtifact.deliveryUnit.unitId,
     buildMarker: buildArtifact.deliveryUnit.buildMarker,

package/src/release-envelope/plugin.ts

@@ -67,14 +67,22 @@ export const createUltramodernReleaseEnvelopePlugin = <
 }): ReleaseEnvelopePlugin<Config> => {
   return {
     name: '@modern-js/ultramodern-release-envelope',
-    pre: ['@modern-js/backend-federation-build', '@modern-js/plugin-bff'],
+    pre: [
+      '@modern-js/backend-federation-build',
+      '@modern-js/plugin-bff',
+      '@modern-js/deploy-output-aliases',
+    ],
     post: ['@modern-js/plugin-deploy'],
     setup(api) {
-      const emitBuildEnvelope = async (target: 'node' | 'cloudflare') => {
+      const emitBuildEnvelope = async (
+        target: 'node' | 'cloudflare',
+        requirePromotable = true,
+      ) => {
         const { apiOnly, distDirectory } = api.getAppContext();
         await emitFrameworkMicroVerticalReleaseEnvelope({
           apiOnly,
           distDirectory,
+          requirePromotable,
           target,
         });
       };
@@ -84,7 +92,11 @@ export const createUltramodernReleaseEnvelopePlugin = <
         if (configuredTarget !== 'node' && configuredTarget !== 'cloudflare') {
           return;
         }
-        await emitBuildEnvelope(configuredTarget);
+        // A plain `modern build` is the development path: a dirty or non-Git
+        // checkout resolves to the `workspace` source revision, which is not
+        // promotable but must still build. Deploy re-emits the envelope and
+        // verifies it, so the release gate keeps its teeth there.
+        await emitBuildEnvelope(configuredTarget, false);
       });
 
       api.onBeforeDeploy(async () => {

package/src/release-identity.ts

@@ -15,7 +15,8 @@ const gitOutput = (
   args: string[],
 ): string | undefined => {
   try {
-    return execFileSync('git', ['-C', workspaceRoot, ...args], {
+    return execFileSync('git', args, {
+      cwd: workspaceRoot,
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
@@ -84,7 +85,7 @@ export const resolveUltramodernSourceRevision = (
   const revision = gitOutput(gitRoot, ['rev-parse', 'HEAD']);
   const status = gitOutput(gitRoot, [
     'status',
-    '--porcelain=v1',
+    '--porcelain',
     '--untracked-files=all',
   ]);
   if (!revision || status === undefined || status.length > 0) {