wip

Author: pavelsavara

src/coreclr/hosts/corerun/CMakeLists.txt

@@ -76,7 +76,7 @@ else()
                 -sSTACK_SIZE=5MB
                 -sMODULARIZE=1
                 -sEXPORT_ES6=1
-                -sEXPORTED_RUNTIME_METHODS=${CMAKE_EMCC_EXPORTED_RUNTIME_METHODS}
+                -sEXPORTED_RUNTIME_METHODS=ENV,${CMAKE_EMCC_EXPORTED_RUNTIME_METHODS}
                 -sEXPORTED_FUNCTIONS=_main,${CMAKE_EMCC_EXPORTED_FUNCTIONS}
                 -sEXPORT_NAME=createDotnetRuntime
                 -sENVIRONMENT=node,shell,web

src/native/corehost/browserhost/CMakeLists.txt

@@ -110,7 +110,6 @@ target_link_options(browserhost PRIVATE
     -sMAXIMUM_MEMORY=2147483648
     -sALLOW_MEMORY_GROWTH=1
     -sSTACK_SIZE=5MB
-    -sWASM_BIGINT=1
     -sMODULARIZE=1
     -sEXPORT_ES6=1
     -sEXIT_RUNTIME=0

src/native/corehost/browserhost/libBrowserHost.footer.js

@@ -45,8 +45,8 @@
                             !config.environmentVariables) {
                             throw new Error("Invalid runtime config, cannot initialize the runtime.");
                         }
-                        const assemblyPaths = config.resources.assembly.map(a => "/" + a.virtualPath);
-                        const coreAssemblyPaths = config.resources.coreAssembly.map(a => "/" + a.virtualPath);
+                        const assemblyPaths = config.resources.assembly.map(a => a.virtualPath);
+                        const coreAssemblyPaths = config.resources.coreAssembly.map(a => a.virtualPath);
                         ENV[HOST_PROPERTY_TRUSTED_PLATFORM_ASSEMBLIES] = config.environmentVariables[HOST_PROPERTY_TRUSTED_PLATFORM_ASSEMBLIES] = [...coreAssemblyPaths, ...assemblyPaths].join(":");
                         ENV[HOST_PROPERTY_NATIVE_DLL_SEARCH_DIRECTORIES] = config.environmentVariables[HOST_PROPERTY_NATIVE_DLL_SEARCH_DIRECTORIES] = config.virtualWorkingDirectory;
                         ENV[HOST_PROPERTY_APP_PATHS] = config.environmentVariables[HOST_PROPERTY_APP_PATHS] = config.virtualWorkingDirectory;

src/native/corehost/browserhost/loader/bootstrap.ts

@@ -1,13 +1,14 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-import type { LoadBootResourceCallback, JsModuleExports, JsAsset, AssemblyAsset, PdbAsset, WasmAsset, IcuAsset, EmscriptenModuleInternal } from "./types";
+import type { LoadBootResourceCallback, JsModuleExports, JsAsset, AssemblyAsset, PdbAsset, WasmAsset, IcuAsset, EmscriptenModuleInternal, LoaderConfig, DotnetHostBuilder } from "./types";
 
 import { dotnetAssert, dotnetGetInternals, dotnetBrowserHostExports, dotnetUpdateInternals } from "./cross-module";
 import { ENVIRONMENT_IS_NODE, ENVIRONMENT_IS_SHELL } from "./per-module";
 import { getLoaderConfig } from "./config";
 import { BrowserHost_InitializeCoreCLR } from "./run";
 import { createPromiseController } from "./promise-controller";
+import { node_fs, node_url } from "./polyfills";
 
 const scriptUrlQuery = /*! webpackIgnore: true */import.meta.url;
 const queryIndex = scriptUrlQuery.indexOf("?");
@@ -143,3 +144,49 @@ function isPathAbsolute(path: string): boolean {
     // windows http://C:/x.json
     return protocolRx.test(path);
 }
+
+export function isShellHosted(): boolean {
+    return ENVIRONMENT_IS_SHELL && typeof (globalThis as any).arguments !== "undefined";
+}
+
+export function isNodeHosted(): boolean {
+    if (!ENVIRONMENT_IS_NODE || globalThis.process.argv.length < 3) {
+        return false;
+    }
+    const argv1 = globalThis.process.argv[1].toLowerCase();
+    const argScript = normalizeFileUrl("file:///" + locateFile(argv1));
+    const importScript = normalizeFileUrl(locateFile(scriptUrl.toLowerCase()));
+
+    return argScript === importScript;
+}
+
+export async function findResources(dotnet: DotnetHostBuilder): Promise<void> {
+    if (!ENVIRONMENT_IS_NODE) {
+        return;
+    }
+    const fs = await node_fs();
+    const url = await node_url();
+    const scriptDir = url.fileURLToPath(scriptDirectory).replace(windowsAbsoluteRx, "/").replace(/\\/g, "/");
+    const files: string[] = await fs.promises.readdir(scriptDir);
+    const assemblies = files
+        // TODO-WASM: webCIL
+        .filter(file => file.endsWith(".dll"))
+        .map(filename => {
+            // filename without path
+            const name = filename.substring(filename.lastIndexOf("/") + 1);
+            return { virtualPath: scriptDir + filename, name };
+        });
+    const config: LoaderConfig = {
+        mainAssemblyName: globalThis.process.argv[2],
+        virtualWorkingDirectory: scriptDir,
+        resources: {
+            jsModuleNative: [{ name: "dotnet.native.js" }],
+            jsModuleRuntime: [{ name: "dotnet.runtime.js" }],
+            wasmNative: [{ name: "dotnet.native.wasm", }],
+            coreAssembly: [{ virtualPath: scriptDir + "System.Private.CoreLib.dll", name: "System.Private.CoreLib.dll" },],
+            assembly: assemblies,
+        }
+    };
+    dotnet.withConfig(config);
+    dotnet.withApplicationArguments(...globalThis.process.argv.slice(3));
+}

src/native/corehost/browserhost/loader/dotnet.ts

@@ -14,10 +14,14 @@ import { HostBuilder } from "./host-builder";
 import { initPolyfills, initPolyfillsAsync } from "./polyfills";
 import { exit } from "./exit";
 import { dotnetInitializeModule } from ".";
+import { selfHostNodeJS } from "./run";
 
 initPolyfills();
 dotnetInitializeModule();
 await initPolyfillsAsync();
 
 export const dotnet: DotnetHostBuilder | undefined = new HostBuilder() as DotnetHostBuilder;
 export { exit };
+
+// Auto-start when in Node.js or Shell environment
+selfHostNodeJS(dotnet!);

src/native/corehost/browserhost/loader/polyfills.ts

@@ -48,30 +48,43 @@ export async function initPolyfillsAsync(): Promise<void> {
     // WASM-TODO: performance polyfill for V8
 }
 
+let _node_fs: any | undefined = undefined;
+let _node_url: any | undefined = undefined;
+
+export async function node_fs(): Promise<any> {
+    if (ENVIRONMENT_IS_NODE && !_node_fs) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore:
+        _node_fs = await import(/*! webpackIgnore: true */"fs");
+    }
+    return _node_fs;
+}
+
+export async function node_url(): Promise<any> {
+    if (ENVIRONMENT_IS_NODE && !_node_url) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore:
+        _node_url = await import(/*! webpackIgnore: true */"node:url");
+    }
+    return _node_url;
+}
+
 export async function fetchLike(url: string, init?: RequestInit): Promise<Response> {
-    let node_fs: any | undefined = undefined;
-    let node_url: any | undefined = undefined;
     try {
+        await node_fs();
+        await node_url();
         // this need to be detected only after we import node modules in onConfigLoaded
         const hasFetch = typeof (globalThis.fetch) === "function";
         if (ENVIRONMENT_IS_NODE) {
             const isFileUrl = url.startsWith("file://");
             if (!isFileUrl && hasFetch) {
                 return globalThis.fetch(url, init || { credentials: "same-origin" });
             }
-            if (!node_fs) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore:
-                node_url = await import(/*! webpackIgnore: true */"url");
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore:
-                node_fs = await import(/*! webpackIgnore: true */"fs");
-            }
             if (isFileUrl) {
-                url = node_url.fileURLToPath(url);
+                url = _node_url.fileURLToPath(url);
             }
 
-            const arrayBuffer = await node_fs.promises.readFile(url);
+            const arrayBuffer = await _node_fs.promises.readFile(url);
             return <Response><any>{
                 ok: true,
                 headers: {

src/native/corehost/browserhost/loader/run.ts

@@ -1,14 +1,16 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+import { DotnetHostBuilder } from "../types";
+import { findResources, isNodeHosted, isShellHosted } from "./bootstrap";
 import { Module, dotnetAssert } from "./cross-module";
 import { exit } from "./exit";
 import { createPromiseController } from "./promise-controller";
 
 let CoreCLRInitialized = false;
 const runMainPromiseController = createPromiseController<number>();
 
-export function BrowserHost_InitializeCoreCLR():void {
+export function BrowserHost_InitializeCoreCLR(): void {
     dotnetAssert.check(!CoreCLRInitialized, "CoreCLR should be initialized just once");
     CoreCLRInitialized = true;
 
@@ -22,14 +24,29 @@ export function BrowserHost_InitializeCoreCLR():void {
     }
 }
 
-export function resolveRunMainPromise(exitCode:number):void {
+export function resolveRunMainPromise(exitCode: number): void {
     runMainPromiseController.resolve(exitCode);
 }
 
-export function rejectRunMainPromise(reason:any):void {
+export function rejectRunMainPromise(reason: any): void {
     runMainPromiseController.reject(reason);
 }
 
-export function getRunMainPromise():Promise<number> {
+export function getRunMainPromise(): Promise<number> {
     return runMainPromiseController.promise;
 }
+
+// Auto-start when in NodeJS environment as a entry script
+export async function selfHostNodeJS(dotnet: DotnetHostBuilder): Promise<void> {
+    try {
+        if (isNodeHosted()) {
+            await findResources(dotnet);
+            await dotnet.run();
+        } else if (isShellHosted()) {
+            // because in V8 we can't probe directories to find assemblies
+            throw new Error("Shell/V8 hosting is not supported");
+        }
+    } catch (err: any) {
+        exit(1, err);
+    }
+}

src/native/rollup.config.defines.js

@@ -18,7 +18,7 @@ if (process.env.ProductVersion === undefined) {
 export const configuration = process.env.Configuration !== "Release" && process.env.Configuration !== "RELEASE" ? "Debug" : "Release";
 export const productVersion = process.env.ProductVersion;
 export const isContinuousIntegrationBuild = process.env.ContinuousIntegrationBuild === "true" ? true : false;
-export const staticLibDestination = process.env.StaticLibDestination;
+export const staticLibDestination = process.env.StaticLibDestination || "../../artifacts/bin/browser-wasm.Debug/corehost"; // TODO "../../artifacts/bin/native/net10.0-browser-Debug-wasm/sharedFramework";
 
 console.log(`Rollup configuration: Configuration=${configuration}, ProductVersion=${productVersion}, ContinuousIntegrationBuild=${isContinuousIntegrationBuild}`);