@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

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,252 +11,50 @@ 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';
+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}`,
+  );
+}
+const {
+  effectCompilerDiscoveryFailureStage,
+  resolveInstalledEffectCompiler,
+}: typeof import('./internal-effect-discovery') = createRequire(
+  owningModuleUrl,
+)(`${owningName}/internal-effect-discovery`);
 
-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,
-  );
-
-  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);
-}
 
-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);
-    }
-  }
-}
-
-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 {
@@ -268,7 +65,9 @@ function resolveExecutableEffectTsgoCompiler(compilerPath: string): string {
   const sourcePath = realpathSync(compilerPath);
   const source = lstatSync(sourcePath);
   if (!source.isFile()) {
-    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    throw new Error(
+      `Effect TS-Go compiler path is not a regular file: ${sourcePath}`,
+    );
   }
 
   try {
@@ -333,37 +132,6 @@ 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;
@@ -381,24 +149,30 @@ export function resolveEffectTsgoCompiler(
   if (configuredCompiler) {
     try {
       return resolveExecutableEffectTsgoCompiler(configuredCompiler);
-    } catch {
-      throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    } 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);
 }

package/src/build-config/internal-effect-discovery.ts

@@ -0,0 +1,239 @@
+import { lstatSync, readFileSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, type URL } from 'node:url';
+
+const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
+const EFFECT_TSGO_BIN = 'effect-tsgo';
+const NATIVE_TYPESCRIPT_PACKAGES = ['typescript', '@typescript/native'];
+type PackageJson = {
+  name?: string;
+  bin?: Record<string, string> | string;
+  version?: string;
+  gitHead?: string;
+};
+const failureStages = new WeakMap<object, string>();
+export function effectCompilerDiscoveryFailureStage(
+  error: unknown,
+): string | undefined {
+  return error && typeof error === 'object'
+    ? failureStages.get(error)
+    : undefined;
+}
+
+function resolveEffectTsgoPackage(from: string | URL): {
+  packageJsonPath: string;
+  packageJson: PackageJson;
+  cliPath: 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(
+      `Resolved ${EFFECT_TSGO_PACKAGE} package has no ${EFFECT_TSGO_BIN} bin: ${packageJsonPath}`,
+    );
+  }
+
+  const cliPath = realpathSync(resolve(dirname(packageJsonPath), bin));
+  if (!lstatSync(cliPath).isFile())
+    throw new Error(`Effect TS-Go CLI is not a regular file: ${cliPath}`);
+  return { packageJsonPath, packageJson, cliPath };
+}
+
+function isAbsentNativeTypeScriptPackage(
+  projectRequire: NodeJS.Require,
+  from: string | URL,
+  packageName: string,
+  error: unknown,
+): boolean {
+  const filename =
+    typeof from === 'string' && !from.startsWith('file:')
+      ? from
+      : fileURLToPath(from);
+  if (
+    !(error instanceof Error) ||
+    !('code' in error) ||
+    error.code !== 'MODULE_NOT_FOUND' ||
+    ('path' in error && error.path !== undefined) ||
+    error.message.split('\n')[0] !==
+      `Cannot find module '${packageName}/package.json'` ||
+    !('requireStack' in error) ||
+    !Array.isArray(error.requireStack) ||
+    error.requireStack[0] !== filename
+  ) {
+    return false;
+  }
+  for (const searchDirectory of projectRequire.resolve.paths(packageName) ??
+    []) {
+    try {
+      lstatSync(join(searchDirectory, packageName));
+      return false;
+    } catch (presenceError) {
+      if (
+        !(presenceError instanceof Error) ||
+        !('code' in presenceError) ||
+        !['ENOENT', 'ENOTDIR'].includes(String(presenceError.code))
+      ) {
+        throw presenceError;
+      }
+    }
+  }
+  return true;
+}
+
+function resolveNativeTypeScriptPackage(from: string | URL): string {
+  const projectRequire = createRequire(from);
+  for (const packageName of NATIVE_TYPESCRIPT_PACKAGES) {
+    let packageJsonPath: string;
+    try {
+      packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
+    } catch (error) {
+      if (
+        isAbsentNativeTypeScriptPackage(
+          projectRequire,
+          from,
+          packageName,
+          error,
+        )
+      ) {
+        continue;
+      }
+      throw error;
+    }
+    const packageJson = JSON.parse(
+      readFileSync(packageJsonPath, 'utf-8'),
+    ) as PackageJson;
+    const major = packageJson.version?.match(
+      /^(\d+)\.\d+\.\d+(?:[-+].*)?$/u,
+    )?.[1];
+    if (!major) {
+      throw new Error(
+        `Resolved TypeScript package has no valid version: ${packageJsonPath}`,
+      );
+    }
+    if (Number(major) >= 7) {
+      return packageJsonPath;
+    }
+  }
+  throw new Error(
+    `No native TypeScript backend is installed for ${String(from)}. Install typescript >=7 or @typescript/native.`,
+  );
+}
+
+function resolveNativeTypeScriptManifest(from: string | URL): string {
+  const packageJsonPath = resolveNativeTypeScriptPackage(from);
+  const directory = dirname(packageJsonPath);
+  // Keep the selected backend bound to its own installation, including the
+  // canonical-package precedence used by the provider.
+  const discoveryPackage = resolveNativeTypeScriptPackage(
+    join(directory, '__ultramodern_effect_backend__.cjs'),
+  );
+  if (realpathSync(discoveryPackage) !== realpathSync(packageJsonPath)) {
+    throw new Error(
+      `Effect discovery would select a different native TypeScript installation from ${directory}: ${discoveryPackage}`,
+    );
+  }
+  return packageJsonPath;
+}
+
+function readCompilerArtifact(filename: string): string {
+  const canonicalPath = realpathSync(filename);
+  const stats = lstatSync(canonicalPath);
+  if (!stats.isFile())
+    throw new Error(`Compiler artifact is not a regular file: ${filename}`);
+  if (stats.size === 0)
+    throw new Error(`Compiler artifact is empty: ${filename}`);
+  return canonicalPath;
+}
+
+/** Selects the exact native replacement without invoking the provider. */
+export function resolveInstalledEffectCompiler(from: string | URL): string {
+  let stage = 'Package CLI resolution';
+  try {
+    const effect = resolveEffectTsgoPackage(from);
+    stage = 'Native TypeScript package resolution';
+    const typeScriptManifest = resolveNativeTypeScriptManifest(from);
+    const typeScript = JSON.parse(
+      readFileSync(typeScriptManifest, 'utf8'),
+    ) as PackageJson;
+    const nativeName = `@typescript/typescript-${process.platform}-${process.arch}`;
+    const nativeManifest = createRequire(typeScriptManifest).resolve(
+      `${nativeName}/package.json`,
+    );
+    const native = JSON.parse(
+      readFileSync(nativeManifest, 'utf8'),
+    ) as PackageJson;
+    if (
+      native.name !== nativeName ||
+      native.version !== typeScript.version ||
+      typeof native.version !== 'string' ||
+      !/^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/u.test(native.version) ||
+      typeof native.gitHead !== 'string' ||
+      !/^[a-f\d]{40}$/u.test(native.gitHead) ||
+      native.gitHead !== typeScript.gitHead
+    ) {
+      throw new Error(
+        `Native TypeScript platform does not match its selected package: ${nativeManifest}`,
+      );
+    }
+    const binaryName = process.platform === 'win32' ? 'tsc.exe' : 'tsc';
+    readCompilerArtifact(join(dirname(nativeManifest), 'lib', binaryName));
+    stage = 'Compiler backend lookup';
+    const effectName = `@effect/tsgo-${process.platform}-${process.arch}`;
+    const effectManifest = createRequire(effect.cliPath).resolve(
+      `${effectName}/package.json`,
+    );
+    const platform = JSON.parse(
+      readFileSync(effectManifest, 'utf8'),
+    ) as PackageJson;
+    if (
+      platform.name !== effectName ||
+      typeof effect.packageJson.version !== 'string' ||
+      platform.version !== effect.packageJson.version
+    ) {
+      throw new Error(
+        `Effect platform does not match its selected provider: ${effectManifest}`,
+      );
+    }
+    const metadataPath = join(dirname(effectManifest), 'lib', 'upstream.json');
+    const metadata = JSON.parse(readFileSync(metadataPath, 'utf8')) as {
+      schemaVersion?: number;
+      components?: {
+        typescript?: Record<string, { gitHead?: string; provider?: string }>;
+      };
+    };
+    const component = metadata.components?.typescript?.[native.version];
+    if (
+      metadata.schemaVersion !== 5 ||
+      component?.provider !== 'typescript-go' ||
+      component.gitHead !== native.gitHead
+    ) {
+      throw new Error(
+        `Effect replacement metadata does not match the selected native TypeScript backend: ${metadataPath}`,
+      );
+    }
+    return readCompilerArtifact(
+      join(
+        dirname(effectManifest),
+        'artifacts',
+        'typescript',
+        native.version,
+        binaryName,
+      ),
+    );
+  } catch (error) {
+    if (error && typeof error === 'object' && !failureStages.has(error))
+      failureStages.set(error, stage);
+    throw error;
+  }
+}

package/src/build-config/public.ts

@@ -2,5 +2,4 @@ export type { ResolveEffectTsgoCompilerOptions } from './build-environment';
 export {
   getBuildConfigEnvironment,
   resolveEffectTsgoCompiler,
-  withBuildConfigEnvironment,
 } 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}`
+  );
+}