@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/src/native-type-checker.ts

@@ -1,13 +1,89 @@
-import { execFile } from 'node:child_process';
-import { existsSync, realpathSync } from 'node:fs';
+import { execFile, execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import {
+  existsSync,
+  readFileSync,
+  realpathSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { refreshTsgoCheckerConfig } from '@modern-js/builder';
 import type { Rspack, RspackChain } from '@rsbuild/core';
+import { type ParseError, parse, printParseErrorCode } from 'jsonc-parser';
+import { resolveEffectTsgoCompiler } from './build-config/build-environment';
 
 const execute = promisify(execFile);
 const name = 'UltramodernNativeTypeChecker';
 
+export interface NativeTypeCheckerCommand {
+  executable: string;
+  args: readonly string[];
+  /** The selected package's native config API. tsrs has no --showConfig CLI. */
+  configApi?: string;
+}
+
+/** Resolve the Effect-enabled native compiler from the application's origin. */
+export function resolveNativeTypeCheckerCommand(
+  from: string,
+): NativeTypeCheckerCommand {
+  const executable = resolveEffectTsgoCompiler({ from });
+  const version = execFileSync(executable, ['--version'], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      TSRS_CHECKER_ASSIGNMENT: process.env.TSRS_CHECKER_ASSIGNMENT || 'go',
+    },
+    timeout: 10_000,
+  });
+  if (version.includes('(tsrs ')) {
+    return {
+      executable,
+      args: [],
+      configApi: createRequire(from).resolve('tsrs/sync'),
+    };
+  }
+  // TypeScript-Go supports --showConfig, including project references. Its
+  // older native config API lacks tsrs's diagnostics and reference fields.
+  return {
+    executable,
+    args: [],
+  };
+}
+
+// Use the real native parser, not a handwritten tsconfig/extends interpreter.
+// Running the client in a child also applies assignment to its native API
+// process without changing the build/dev server's environment.
+const inspectNativeConfig = `
+  import { pathToFileURL } from 'node:url';
+  const [modulePath, compiler, configFile] = process.argv.slice(1);
+  const { API, formatDiagnostics } = await import(pathToFileURL(modulePath).href);
+  const api = new API({ tsserverPath: compiler });
+  try {
+    const config = api.parseConfigFile(configFile);
+    if (config.errors.length) {
+      process.stdout.write(formatDiagnostics(config.errors, api));
+      process.exitCode = 1;
+    } else {
+      process.stdout.write(JSON.stringify({
+        compilerOptions: config.options,
+        files: config.fileNames,
+        references: config.projectReferences,
+      }));
+    }
+  } finally {
+    api.close();
+  }
+`;
+
+interface TypeCheckerConfig {
+  compilerOptions?: Record<string, unknown>;
+  references?: Array<{ path: string }>;
+  [key: string]: unknown;
+}
+
 // 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.
@@ -20,17 +96,151 @@ const watchDependencyPath = (file: string): string => {
   }
 };
 
+/**
+ * TS2875 means JSX compiles against a jsxImportSource whose runtime is not
+ * installed: usually components still authored for a previous renderer.
+ */
+export function missingJsxRuntimeHint(diagnostics: string): string {
+  const source =
+    /error TS2875: This JSX tag requires the module path '(.+?)\/jsx-(?:dev-)?runtime'/u.exec(
+      diagnostics,
+    )?.[1];
+  if (!source) return '';
+  return `\nHint: JSX compiles against jsxImportSource '${source}', the selected renderer's runtime, but '${source}/jsx-runtime' cannot be resolved from this app. If you changed \`renderer\` in modern.config, install that renderer's packages and port components authored for the previous renderer, or switch \`renderer\` back.\n`;
+}
+
 export class UltramodernNativeTypeChecker {
   constructor(
     private readonly options: {
-      compiler: () => string;
+      compiler: () => string | NativeTypeCheckerCommand;
       configFile: string;
       build: boolean;
+      configOverwrite?: TypeCheckerConfig;
     },
   ) {}
 
   async check(): Promise<void> {
-    const { configFile, build } = this.options;
+    const configFile = await this.projectConfigFile();
+    try {
+      await this.checkProject(configFile);
+    } finally {
+      this.removeProjection(configFile);
+    }
+  }
+
+  private async projectConfigFile(): Promise<string> {
+    const { configFile, configOverwrite } = this.options;
+    if (!configOverwrite) return configFile;
+    // Merge before native parsing: an overwrite may supply the inputs that
+    // make an otherwise empty project valid. A same-directory projection
+    // preserves the original extends, relative paths and project references.
+    const errors: ParseError[] = [];
+    const source = readFileSync(configFile, 'utf8');
+    const project: TypeCheckerConfig = parse(
+      source.charCodeAt(0) === 0xfeff ? source.slice(1) : source,
+      errors,
+      { allowTrailingComma: true },
+    );
+    if (errors.length) {
+      throw new Error(
+        `${name} requires valid JSONC in ${configFile}: ${errors
+          .map(
+            error => `${printParseErrorCode(error.error)} at ${error.offset}`,
+          )
+          .join(', ')}`,
+      );
+    }
+    if (!project || typeof project !== 'object' || Array.isArray(project)) {
+      throw new Error(`${name} requires a JSONC object in ${configFile}.`);
+    }
+    const projectedConfig: TypeCheckerConfig = {
+      ...project,
+      ...configOverwrite,
+      compilerOptions: {
+        ...project.compilerOptions,
+        ...configOverwrite.compilerOptions,
+      },
+    };
+    const projected = path.join(
+      path.dirname(configFile),
+      `.ultramodern-native-checker.${randomUUID()}.json`,
+    );
+    writeFileSync(projected, `${JSON.stringify(projectedConfig, null, 2)}\n`, {
+      flag: 'wx',
+    });
+    try {
+      const resolved: TypeCheckerConfig = JSON.parse(
+        await this.run(['--showConfig', '--project', projected]),
+      );
+      const options = resolved.compilerOptions ?? {};
+      if (
+        (this.options.build ||
+          options.incremental === true ||
+          options.composite === true) &&
+        !options.tsBuildInfoFile
+      ) {
+        // Native TypeScript derives the default from the config filename.
+        // Retain that original identity while this invocation-private config
+        // is alive; referenced projects still use their own configurations.
+        const original = configFile.slice(
+          0,
+          configFile.length - path.extname(configFile).length,
+        );
+        let buildInfo = original;
+        if (typeof options.outDir === 'string') {
+          const outDir = path.resolve(path.dirname(configFile), options.outDir);
+          buildInfo =
+            typeof options.rootDir === 'string'
+              ? path.resolve(
+                  outDir,
+                  path.relative(
+                    path.resolve(path.dirname(configFile), options.rootDir),
+                    original,
+                  ),
+                )
+              : path.join(outDir, path.basename(original));
+        }
+        projectedConfig.compilerOptions = {
+          ...projectedConfig.compilerOptions,
+          tsBuildInfoFile: `${buildInfo}.tsbuildinfo`,
+        };
+        writeFileSync(
+          projected,
+          `${JSON.stringify(projectedConfig, null, 2)}\n`,
+        );
+      }
+      return projected;
+    } catch (error) {
+      unlinkSync(projected);
+      throw error;
+    }
+  }
+
+  private removeProjection(configFile: string): void {
+    if (configFile !== this.options.configFile) unlinkSync(configFile);
+  }
+
+  private async checkProject(configFile: string): Promise<void> {
+    const { 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'];
@@ -39,28 +249,63 @@ export class UltramodernNativeTypeChecker {
 
   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,
-      });
+      const selected = this.options.compiler();
+      const command: NativeTypeCheckerCommand =
+        typeof selected === 'string'
+          ? { executable: selected, args: [] }
+          : selected;
+      const inspect = args[0] === '--showConfig' && command.configApi;
+      const result = await execute(
+        inspect ? process.execPath : command.executable,
+        inspect
+          ? [
+              '--input-type=module',
+              '--eval',
+              inspectNativeConfig,
+              command.configApi!,
+              command.executable,
+              args[args.indexOf('--project') + 1],
+            ]
+          : [...command.args, ...args],
+        {
+          cwd: path.dirname(this.options.configFile),
+          // Apply to every command, including explicit paths and TSRS_BINARY.
+          // Keep caller selection; do not change the dev server's environment.
+          env: {
+            ...process.env,
+            TSRS_CHECKER_ASSIGNMENT:
+              process.env.TSRS_CHECKER_ASSIGNMENT || 'go',
+          },
+          maxBuffer: 16 * 1024 * 1024,
+          ...(inspect ? { timeout: 10_000 } : {}),
+        },
+      );
       return result.stdout;
     } catch (cause) {
-      const output = cause as { stdout?: string; stderr?: string };
+      const output = cause as {
+        stdout?: string;
+        stderr?: string;
+        code?: number | string;
+        signal?: NodeJS.Signals;
+      };
       const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
-      throw new Error(
-        `${name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`,
-        { cause },
+      throw Object.assign(
+        new Error(
+          `${name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}${missingJsxRuntimeHint(diagnostics)}`,
+          { cause },
+        ),
+        { code: output.code, signal: output.signal },
       );
     }
   }
 
-  private async watchInputs(): Promise<{
+  private async watchInputs(configFile: string): Promise<{
     inputs: Set<string>;
     missing: Set<string>;
   }> {
     const inputs = new Set<string>();
     const missing = new Set<string>();
-    const projects = [this.options.configFile];
+    const projects = [configFile];
     const visited = new Set<string>();
     for (const configFile of projects) {
       if (visited.has(configFile)) continue;
@@ -68,7 +313,8 @@ export class UltramodernNativeTypeChecker {
       // 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 (configFile === this.options.configFile || configFile !== projects[0])
+        inputs.add(configFile);
       if (!existsSync(configFile)) {
         missing.add(configFile);
         continue;
@@ -120,17 +366,20 @@ export class UltramodernNativeTypeChecker {
               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();
+          const configFile = await this.projectConfigFile();
+          try {
+            const { inputs, missing } = await this.watchInputs(configFile);
+            for (const file of inputs)
+              compilation.fileDependencies.add(watchDependencyPath(file));
+            for (const file of missing)
+              compilation.missingDependencies.add(watchDependencyPath(file));
+            await this.checkProject(configFile);
+          } finally {
+            this.removeProjection(configFile);
+          }
         } catch (cause) {
           compilation.errors.push(
-            new Error(cause instanceof Error ? cause.message : String(cause), {
-              cause,
-            }),
+            cause instanceof Error ? cause : new Error(String(cause)),
           );
         }
       });
@@ -138,15 +387,22 @@ export class UltramodernNativeTypeChecker {
   }
 }
 
-/** Preserve project-reference emit contracts in the native Effect compiler. */
+/** Preserve project-reference emit contracts in the selected native compiler. */
 export function configureUltramodernTypeChecker(
   chain: RspackChain,
   pluginId: string,
-  resolveCompiler: (configFile: string) => string,
+  resolveCompiler: (configFile: string) => string | NativeTypeCheckerCommand,
 ): void {
   if (!chain.plugins.has(pluginId)) return;
   const options = chain.plugin(pluginId).get('args')?.[0] as
-    | { typescript?: { configFile?: string; build?: boolean; tsgo?: boolean } }
+    | {
+        typescript?: {
+          configFile?: string;
+          build?: boolean;
+          tsgo?: boolean;
+          configOverwrite?: TypeCheckerConfig;
+        };
+      }
     | undefined;
   const typescript = options?.typescript;
   if (typescript?.tsgo === false) return;
@@ -159,6 +415,7 @@ export function configureUltramodernTypeChecker(
       build: typescript.build === true,
       compiler: () => resolveCompiler(configFile),
       configFile,
+      configOverwrite: typescript.configOverwrite,
     },
   ]);
 }

package/src/policy-defaults.ts

@@ -22,6 +22,9 @@ export const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
 export const SERVER_EXTENSIONS_PLUGIN_NAME =
   '@modern-js/app-tools/server-plugin';
 
+export const ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME =
+  '@modern-js/ultramodern-app-tools/server-plugin';
+
 export interface PolicyDefaultsOptions {
   /** Default `true`. Set to `false` to drop the fork's renderer policy. */
   rendererExtensions?: boolean;
@@ -29,6 +32,16 @@ export interface PolicyDefaultsOptions {
   serverExtensions?: boolean;
 }
 
+/** The native package that explicitly composes the policy. */
+export interface PolicyDefaultsComposition {
+  pluginName?: string;
+  serverPluginName?: string;
+  /** Additional runtime packages that share the resolution fallback. */
+  runtimePackages?: readonly string[];
+  /** Resolve runtime packages from the composing package. */
+  registrarUrl?: string;
+}
+
 type RuntimePluginDescriptor = {
   name?: string;
   path: string;
@@ -62,6 +75,7 @@ export const POLICY_DEFAULTS_PLUGIN_NAME =
 export const applyPolicyDefaults = (
   api: PolicyDefaultsPluginApi,
   options: PolicyDefaultsOptions = {},
+  composition: PolicyDefaultsComposition = {},
 ): void => {
   if (options.rendererExtensions !== false) {
     api._internalRuntimePlugins(
@@ -80,28 +94,43 @@ export const applyPolicyDefaults = (
         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),
-        ],
-      }));
-    }
+  const runtimePackages = [
+    ...(options.rendererExtensions !== false
+      ? [RENDERER_EXTENSIONS_PACKAGE]
+      : []),
+    ...(composition.runtimePackages ?? []).filter(
+      packageName => packageName !== RENDERER_EXTENSIONS_PACKAGE,
+    ),
+  ];
+  const moduleDirectories = collectRuntimePackageModuleDirectories(
+    runtimePackages,
+    composition.registrarUrl ?? import.meta.url,
+  );
+  if (moduleDirectories.length > 0) {
+    api.modifyResolvedConfig(config => ({
+      ...config,
+      builderPlugins: [
+        ...(config.builderPlugins ?? []),
+        createRuntimePackageResolutionPlugin(moduleDirectories),
+      ],
+    }));
   }
 
   if (options.serverExtensions !== false) {
+    const serverPluginName =
+      composition.serverPluginName ?? SERVER_EXTENSIONS_PLUGIN_NAME;
     api._internalServerPlugins(({ plugins }: ServerPluginsInput) => {
       if (
-        !plugins.some(plugin => plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)
+        !plugins.some(
+          plugin =>
+            plugin.name === serverPluginName ||
+            plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME ||
+            plugin.name === ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME,
+        )
       ) {
-        plugins.push({ name: SERVER_EXTENSIONS_PLUGIN_NAME });
+        plugins.push({ name: serverPluginName });
       }
       return { plugins };
     });
@@ -119,9 +148,10 @@ export const applyPolicyDefaults = (
  */
 export const createPolicyDefaultsPlugin = (
   options: PolicyDefaultsOptions = {},
+  composition: PolicyDefaultsComposition = {},
 ) => ({
-  name: POLICY_DEFAULTS_PLUGIN_NAME,
+  name: composition.pluginName ?? POLICY_DEFAULTS_PLUGIN_NAME,
   setup(api: PolicyDefaultsPluginApi) {
-    applyPolicyDefaults(api, options);
+    applyPolicyDefaults(api, options, composition);
   },
 });

package/src/release-envelope/canonical.ts

@@ -1,8 +1,7 @@
 import { createHash } from 'node:crypto';
-import type {
-  MicroVerticalReleaseEnvelope,
-  MicroVerticalReleaseEnvelopePayload,
-} from './types';
+import type { ReleaseEnvelope, ReleaseEnvelopePayload } from './types';
+
+export { releaseEnvelopePayload } from './contract.mjs';
 
 type CanonicalValue =
   | null
@@ -31,27 +30,16 @@ const serializeCanonicalValue = (value: CanonicalValue): string => {
     .join(',')}}`;
 };
 
-export const releaseEnvelopePayload = (
-  envelope: MicroVerticalReleaseEnvelope,
-): MicroVerticalReleaseEnvelopePayload => ({
-  schemaVersion: envelope.schemaVersion,
-  kind: envelope.kind,
-  target: envelope.target,
-  identity: envelope.identity,
-  artifacts: envelope.artifacts,
-  surfaces: envelope.surfaces,
-});
-
 export const canonicalSerializeMicroVerticalReleaseEnvelopePayload = (
-  payload: MicroVerticalReleaseEnvelopePayload,
+  payload: ReleaseEnvelopePayload,
 ) => serializeCanonicalValue(payload as unknown as CanonicalValue);
 
 export const canonicalSerializeMicroVerticalReleaseEnvelope = (
-  envelope: MicroVerticalReleaseEnvelope,
+  envelope: ReleaseEnvelope,
 ) => serializeCanonicalValue(envelope as unknown as CanonicalValue);
 
 export const digestMicroVerticalReleaseEnvelopePayload = (
-  payload: MicroVerticalReleaseEnvelopePayload,
+  payload: ReleaseEnvelopePayload,
 ) =>
   createHash('sha256')
     .update(canonicalSerializeMicroVerticalReleaseEnvelopePayload(payload))

package/src/release-envelope/contract.mjs

@@ -0,0 +1,28 @@
+export const MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION =
+  /** @type {const} */ (5);
+
+export const MICROVERTICAL_RELEASE_ENVELOPE_KIND = /** @type {const} */ (
+  'ultramodern-target-microvertical-release-envelope'
+);
+
+export const SHELL_RELEASE_ENVELOPE_KIND = /** @type {const} */ (
+  'ultramodern-target-shell-release-envelope'
+);
+
+/**
+ * @param {import('./types.js').ReleaseEnvelope} envelope
+ * @returns {import('./types.js').ReleaseEnvelopePayload}
+ */
+export const releaseEnvelopePayload = envelope => {
+  const payload = {
+    schemaVersion: envelope.schemaVersion,
+    target: envelope.target,
+    identity: envelope.identity,
+    ...(envelope.ui ? { ui: envelope.ui } : {}),
+    artifacts: envelope.artifacts,
+  };
+  if (envelope.kind === SHELL_RELEASE_ENVELOPE_KIND) {
+    return { ...payload, kind: envelope.kind, surfaces: envelope.surfaces };
+  }
+  return { ...payload, kind: envelope.kind, surfaces: envelope.surfaces };
+};