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

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

@@ -1,4 +1,3 @@
-import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import {
   accessSync,
@@ -12,264 +11,62 @@ import {
   rmSync,
   writeFileSync,
 } from 'node:fs';
-import { createRequire } from 'node:module';
+import { createRequire, findPackageJSON } from 'node:module';
 import { tmpdir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
-import type { URL } from 'node:url';
-import type { Rspack } from '@rsbuild/core';
-
-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>();
-const BUILD_CONFIG_ENVIRONMENT_PLUGIN =
-  'ModernJsBuildConfigEnvironmentLeasePlugin';
-const ENVIRONMENT_LEASE_REGISTRY_KEY = Symbol.for(
-  '@modern-js/app-tools/build-config-environment-lease-registry/v1',
-);
-const ENVIRONMENT_LEASE_REGISTRY_BRAND = Symbol.for(
-  '@modern-js/app-tools/build-config-environment-lease-registry-brand/v1',
-);
-const LIFECYCLE_HOOK_NAMES = [
-  'run',
-  'watchRun',
-  'afterDone',
-  'failed',
-  'shutdown',
-  'watchClose',
-] as const;
-
-type PackageJson = {
-  bin?: Record<string, string> | string;
-};
-
-type EnvironmentLease = {
-  originalValue: string | undefined;
-  owners: Set<symbol>;
-  value: string;
-};
-
-type EnvironmentLeaseRegistry = Readonly<{
-  acquire: (name: string, value: string) => () => void;
-  brand: symbol;
-}>;
-
-type LifecycleHookName = (typeof LIFECYCLE_HOOK_NAMES)[number];
-
-type LifecycleHook = {
-  tap: (options: { name: string; stage: number }, handler: () => void) => void;
-};
-
-function restoreEnvironment(name: string, value: string | undefined): void {
-  if (value === undefined) {
-    delete process.env[name];
-  } else {
-    process.env[name] = value;
-  }
-}
-
-function createEnvironmentLeaseRegistry(): EnvironmentLeaseRegistry {
-  const environmentLeases = new Map<string, EnvironmentLease>();
-
-  return Object.freeze({
-    acquire(name: string, value: string): () => void {
-      let lease = environmentLeases.get(name);
-
-      if (lease) {
-        if (lease.value !== value) {
-          throw new Error(
-            `Build config environment "${name}" already has an active lease for a different value.`,
-          );
-        }
-        if (process.env[name] !== lease.value) {
-          throw new Error(
-            `Build config environment lease for "${name}" lost ownership before another lease was acquired.`,
-          );
-        }
-      } else {
-        lease = {
-          originalValue: process.env[name],
-          owners: new Set(),
-          value,
-        };
-        process.env[name] = value;
-        environmentLeases.set(name, lease);
-      }
-
-      const owner = Symbol(name);
-      lease.owners.add(owner);
-      let released = false;
-
-      return () => {
-        if (released) {
-          return;
-        }
-
-        if (environmentLeases.get(name) !== lease || !lease.owners.has(owner)) {
-          throw new Error(
-            `Build config environment lease for "${name}" cannot be restored because its ownership record was lost.`,
-          );
-        }
-
-        released = true;
-        const lostOwnership = process.env[name] !== lease.value;
-        lease.owners.delete(owner);
-
-        if (lease.owners.size === 0) {
-          environmentLeases.delete(name);
-          restoreEnvironment(name, lease.originalValue);
-        } else if (lostOwnership) {
-          process.env[name] = lease.value;
-        }
-
-        if (lostOwnership) {
-          throw new Error(
-            `Build config environment lease for "${name}" lost ownership before restoration.`,
-          );
-        }
-      };
-    },
-    brand: ENVIRONMENT_LEASE_REGISTRY_BRAND,
-  });
-}
-
-function getEnvironmentLeaseRegistry(): EnvironmentLeaseRegistry {
-  const descriptor = Object.getOwnPropertyDescriptor(
-    process,
-    ENVIRONMENT_LEASE_REGISTRY_KEY,
+import { basename, join } from 'node:path';
+import { pathToFileURL, type URL } from 'node:url';
+
+// CJS and ESM consumers share the selected-cohort validator in one owning
+// module, including packages whose public name changes during publication.
+const owningModuleUrl =
+  process.env.MODERN_LIB_FORMAT === 'esm'
+    ? import.meta.url
+    : pathToFileURL(__filename).href;
+const owningManifest = findPackageJSON(owningModuleUrl, owningModuleUrl);
+if (!owningManifest)
+  throw new Error('Cannot find owning build-config package manifest');
+const owningName: unknown = JSON.parse(
+  readFileSync(owningManifest, 'utf8'),
+).name;
+if (typeof owningName !== 'string' || owningName.length === 0) {
+  throw new Error(
+    `Invalid owning build-config package name: ${owningManifest}`,
   );
-
-  if (descriptor) {
-    const registry = descriptor.value as
-      | Partial<EnvironmentLeaseRegistry>
-      | undefined;
-    if (
-      descriptor.configurable ||
-      descriptor.enumerable ||
-      descriptor.writable ||
-      registry?.brand !== ENVIRONMENT_LEASE_REGISTRY_BRAND ||
-      typeof registry.acquire !== 'function'
-    ) {
-      throw new Error(
-        'The process-global build config environment lease registry is occupied by an incompatible value.',
-      );
-    }
-    return registry as EnvironmentLeaseRegistry;
-  }
-
-  const registry = createEnvironmentLeaseRegistry();
-  Object.defineProperty(process, ENVIRONMENT_LEASE_REGISTRY_KEY, {
-    configurable: false,
-    enumerable: false,
-    value: registry,
-    writable: false,
-  });
-  return registry;
-}
-
-function acquireEnvironmentLease(name: string, value: string): () => void {
-  return getEnvironmentLeaseRegistry().acquire(name, value);
 }
+const {
+  effectCompilerDiscoveryFailureStage,
+  resolveInstalledEffectCompiler,
+  validateConfiguredEffectCompiler,
+}: typeof import('./internal-effect-discovery') = createRequire(
+  owningModuleUrl,
+)(`${owningName}/internal-effect-discovery`);
 
-function releaseAfterFailure(
-  release: () => void,
-  originalError: unknown,
-): never {
-  try {
-    release();
-  } catch (restorationError) {
-    throw new AggregateError(
-      [originalError, restorationError],
-      'Build config environment setup and restoration both failed.',
-    );
-  }
-
-  throw originalError;
-}
-
-class BuildConfigEnvironmentLeasePlugin {
-  constructor(private readonly release: () => void) {}
-
-  apply(compiler: Rspack.Compiler): void {
-    const hooks = compiler.hooks as unknown as Record<
-      string,
-      LifecycleHook | undefined
-    >;
-
-    try {
-      const lifecycleHooks = {} as Record<LifecycleHookName, LifecycleHook>;
-      for (const hookName of LIFECYCLE_HOOK_NAMES) {
-        const hook = hooks[hookName];
-        if (!hook || typeof hook.tap !== 'function') {
-          throw new Error(
-            `Rspack does not expose the "${hookName}" lifecycle hook required to restore build config environment leases.`,
-          );
-        }
-        lifecycleHooks[hookName] = hook;
-      }
-
-      let mode: 'pending' | 'run' | 'watch' = 'pending';
-      const modeTap = {
-        name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
-        stage: Number.MIN_SAFE_INTEGER,
-      };
-      const releaseTap = {
-        name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
-        stage: Number.MAX_SAFE_INTEGER,
-      };
-      const releaseAfterOneShot = () => {
-        if (mode !== 'watch' && compiler.watchMode !== true) {
-          this.release();
-        }
-      };
-
-      lifecycleHooks.run.tap(modeTap, () => {
-        mode = 'run';
-      });
-      lifecycleHooks.watchRun.tap(modeTap, () => {
-        mode = 'watch';
-      });
-      lifecycleHooks.afterDone.tap(releaseTap, releaseAfterOneShot);
-      lifecycleHooks.failed.tap(releaseTap, releaseAfterOneShot);
-      lifecycleHooks.shutdown.tap(releaseTap, this.release);
-      lifecycleHooks.watchClose.tap(releaseTap, this.release);
-    } catch (error) {
-      releaseAfterFailure(this.release, error);
-    }
-  }
-}
+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. Bundled tsrs requires matching installed tsrs metadata.';
+const executableEffectTsgoCompilers = new Map<string, string>();
 
-function resolveEffectTsgoCli(from: string | URL): string {
-  const projectRequire = createRequire(from);
-  const packageJsonPath = projectRequire.resolve(
-    `${EFFECT_TSGO_PACKAGE}/package.json`,
+function effectTsgoResolutionError(
+  cause: unknown,
+  stage: string,
+  from: string | URL,
+): Error {
+  const detail =
+    cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
+  return new Error(
+    `${EFFECT_TSGO_RESOLUTION_ERROR}\n${stage} failed for ${String(from)}: ${detail}`,
+    { cause },
   );
-  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);
+  if (!source.isFile() || source.size === 0) {
+    throw new Error(
+      `Effect TS-Go compiler path is not a nonempty regular file: ${sourcePath}`,
+    );
   }
+  if (process.platform === 'win32') return compilerPath;
 
   try {
     accessSync(sourcePath, constants.X_OK);
@@ -333,44 +130,15 @@ export function getBuildConfigEnvironment(name: string): string | undefined {
   return process.env[name];
 }
 
-/**
- * Runs a Rspack config setup under a leased environment value. The lease is
- * restored when that compiler reaches any supported terminal hook.
- */
-export function withBuildConfigEnvironment<
-  Config extends { plugins?: Rspack.Plugin[] },
-  SetupArguments extends unknown[],
->(
-  name: string,
-  value: string,
-  setup: (
-    config: Config,
-    ...args: SetupArguments
-  ) => Config | void | Promise<Config | void>,
-): (config: Config, ...args: SetupArguments) => Promise<Config> {
-  return async (config, ...args) => {
-    const release = acquireEnvironmentLease(name, value);
-
-    try {
-      const configured = (await setup(config, ...args)) ?? config;
-      configured.plugins = [
-        ...(configured.plugins ?? []),
-        new BuildConfigEnvironmentLeasePlugin(release),
-      ];
-      return configured;
-    } catch (error) {
-      releaseAfterFailure(release, error);
-    }
-  };
-}
-
 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.
+ * Resolves the Effect-enabled native executable for checking and DTS builds.
+ * Use metadata-bound tsrs where both tsrs and the Effect provider support it.
+ * Unsupported targets use Effect-Go. Missing supported artifacts remain fatal.
  */
 export function resolveEffectTsgoCompiler(
   options: ResolveEffectTsgoCompilerOptions,
@@ -380,25 +148,33 @@ export function resolveEffectTsgoCompiler(
 
   if (configuredCompiler) {
     try {
-      return resolveExecutableEffectTsgoCompiler(configuredCompiler);
-    } catch {
-      throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+      const compiler = resolveExecutableEffectTsgoCompiler(configuredCompiler);
+      validateConfiguredEffectCompiler(compiler, options.from);
+      return compiler;
+    } catch (cause) {
+      throw effectTsgoResolutionError(
+        cause,
+        'Configured compiler validation',
+        options.from,
+      );
     }
   }
 
+  let stage = 'Package CLI resolution';
   try {
-    const compiler = execFileSync(
-      process.execPath,
-      [resolveEffectTsgoCli(options.from), 'get-exe-path'],
-      { encoding: 'utf-8' },
-    ).trim();
+    const compiler = resolveInstalledEffectCompiler(options.from).trim();
+    stage = 'Compiler backend lookup';
 
-    if (compiler) {
-      return resolveExecutableEffectTsgoCompiler(compiler);
+    if (!compiler) {
+      throw new Error('Effect TS-Go discovery returned an empty compiler path');
     }
-  } catch {
-    // Use one stable error for package, platform-binary, and CLI failures.
+    stage = 'Compiler executable validation';
+    return resolveExecutableEffectTsgoCompiler(compiler);
+  } catch (cause) {
+    throw effectTsgoResolutionError(
+      cause,
+      effectCompilerDiscoveryFailureStage(cause) ?? stage,
+      options.from,
+    );
   }
-
-  throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
 }