@lynx-js/web-core-server-canary 0.15.8-canary-20250828-86da1623 → 0.16.0-canary-20250828-c1f8715a

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # @lynx-js/web-core-server
 
-## 0.15.8-canary-20250828061943-86da1623d0bd2cc5fa6dc1642915e5f43a02d350
+## 0.16.0-canary-20250828064127-c1f8715a81b2e69ff46fc363013626db4468c209
+
+### Minor Changes
+
+- refactor: provide the mts a real globalThis ([#1589](https://github.com/lynx-family/lynx-stack/pull/1589))
+
+  Before this change, We create a function wrapper and a fake globalThis for Javascript code.
+
+  This caused some issues.
+
+  After this change, we will create an iframe for createing an isolated Javascript context.
+
+  This means the globalThis will be the real one.
 
 ## 0.15.7
 

package/dist/index.js

@@ -1,6 +1,8 @@
 import node_os from "node:os";
 import promises from "node:fs/promises";
 import node_path from "node:path";
+import node_vm from "node:vm";
+import node_fs from "node:fs";
 var __webpack_modules__ = {
     "../web-style-transformer/dist/standard.js": function(module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.a(module, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
@@ -399,12 +401,6 @@ const lynxElementTemplateMarkerAttribute = 'l-template';
 const lynxPartIdAttribute = 'l-part';
 const lynxDefaultDisplayLinearAttribute = 'lynx-default-display-linear';
 const __lynx_timing_flag = '__lynx_timing_flag';
-const globalMuteableVars = [
-    'registerDataProcessor',
-    'registerWorkletInternal',
-    'lynxWorkletImpl',
-    'runWorklet'
-];
 const systemInfo = {
     platform: 'web',
     lynxSdkVersion: '3.0'
@@ -418,10 +414,6 @@ const inShadowRootStyles = [
     overflow: visible;
   }`
 ];
-const constants_globalDisallowedVars = [
-    'navigator',
-    'postMessage'
-];
 const W3cEventNameToLynx = {
     click: 'tap',
     lynxscroll: 'scroll',
@@ -473,12 +465,12 @@ class Rpc {
         };
     }
     #onMessage = async (message)=>{
-        const handler1 = this.#handlerMap.get(message.name);
-        if (handler1) {
+        const handler = this.#handlerMap.get(message.name);
+        if (handler) {
             const lockViewer = message.sync ? new Int32Array(message.lock) : void 0;
             const replyTempEndpoint = !message.sync && message.retId ? Rpc.createRetEndpoint(message.retId) : void 0;
             try {
-                const result = await handler1(...message.data);
+                const result = await handler(...message.data);
                 let retData, transfer = [];
                 if (message.sync) retData = result;
                 else if (message.hasTransfer) ({ data: retData, transfer } = result || {});
@@ -521,8 +513,8 @@ class Rpc {
     createCall(endpoint) {
         return (...args)=>this.invoke(endpoint, args);
     }
-    registerHandler(endpoint, handler1) {
-        this.#handlerMap.set(endpoint.name, handler1);
+    registerHandler(endpoint, handler) {
+        this.#handlerMap.set(endpoint.name, handler);
         const currentCache = this.#messageCache[endpoint.name];
         if (currentCache?.length) {
             this.#messageCache[endpoint.name] = void 0;
@@ -741,114 +733,49 @@ class LynxCrossThreadContext extends EventTarget {
         });
     }
 }
-const mainThreadInjectVars = [
-    'lynx',
-    'globalThis',
-    '_ReportError',
-    '_SetSourceMapRelease',
-    '__AddConfig',
-    '__AddDataset',
-    '__GetAttributes',
-    '__GetComponentID',
-    '__GetDataByKey',
-    '__GetDataset',
-    '__GetElementConfig',
-    '__GetElementUniqueID',
-    '__GetID',
-    '__GetTag',
-    '__SetAttribute',
-    '__SetConfig',
-    '__SetDataset',
-    '__SetID',
-    '__UpdateComponentID',
-    '__UpdateComponentInfo',
-    '__GetConfig',
-    '__GetAttributeByName',
-    '__UpdateListCallbacks',
-    '__AppendElement',
-    '__ElementIsEqual',
-    '__FirstElement',
-    '__GetChildren',
-    '__GetParent',
-    '__InsertElementBefore',
-    '__LastElement',
-    '__NextElement',
-    '__RemoveElement',
-    '__ReplaceElement',
-    '__ReplaceElements',
-    '__SwapElement',
-    '__CreateComponent',
-    '__CreateElement',
-    '__CreatePage',
-    '__CreateView',
-    '__CreateText',
-    '__CreateRawText',
-    '__CreateImage',
-    '__CreateScrollView',
-    '__CreateWrapperElement',
-    '__CreateList',
-    '__AddEvent',
-    '__GetEvent',
-    '__GetEvents',
-    '__SetEvents',
-    '__AddClass',
-    '__SetClasses',
-    '__GetClasses',
-    '__AddInlineStyle',
-    '__SetInlineStyles',
-    '__SetCSSId',
-    '__OnLifecycleEvent',
-    '__FlushElementTree',
-    '__LoadLepusChunk',
-    'SystemInfo',
-    '_I18nResourceTranslation',
-    '_AddEventListener',
-    '__GetTemplateParts',
-    '__MarkPartElement',
-    '__MarkTemplateElement',
-    '__GetPageElement',
-    '__ElementFromBinary'
-];
-const backgroundInjectVars = [
-    'NativeModules',
-    'globalThis',
-    'lynx',
-    'lynxCoreInject'
+const currentSupportedTemplateVersion = 2;
+const globalDisallowedVars = [
+    'navigator',
+    'postMessage'
 ];
-const backgroundInjectWithBind = [
-    'Card',
-    'Component'
+const templateUpgraders = [
+    (template)=>{
+        const defaultInjectStr = "Card,setTimeout,setInterval,clearInterval,clearTimeout,NativeModules,Component,ReactLynx,nativeAppId,Behavior,LynxJSBI,lynx,window,document,frames,location,navigator,localStorage,history,Caches,screen,alert,confirm,prompt,fetch,XMLHttpRequest,__WebSocket__,webkit,Reporter,print,global,requestAnimationFrame,cancelAnimationFrame";
+        template.manifest = Object.fromEntries(Object.entries(template.manifest).map(([key, value])=>[
+                key,
+                `{init: (lynxCoreInject) => { var {${defaultInjectStr}} = lynxCoreInject.tt; var module = {exports:null}; ${value}\n return module.exports; } }`
+            ]));
+        template.lepusCode = Object.fromEntries(Object.entries(template.lepusCode).map(([key, value])=>[
+                key,
+                `(()=>{${value}\n})();`
+            ]));
+        template.version = 2;
+        return template;
+    }
 ];
-const generateModuleContent = (content, injectVars, injectWithBind, muteableVars, globalDisallowedVars, isESM)=>[
+const generateModuleContent = (content)=>[
         '//# allFunctionsCalledOnLoad\n',
-        isESM ? 'export default ' : 'globalThis.module.exports =',
-        'function(lynx_runtime) {',
-        'const module= {exports:{}};let exports = module.exports;',
-        'var {',
-        injectVars.join(','),
-        '} = lynx_runtime;',
-        ...injectWithBind.map((nm)=>`const ${nm} = lynx_runtime.${nm}?.bind(lynx_runtime);`),
-        ';var globDynamicComponentEntry = \'__Card__\';',
-        0 !== globalDisallowedVars.length ? `var ${globalDisallowedVars.join('=')}=undefined;` : '',
-        'var {__globalProps} = lynx;',
-        'lynx_runtime._updateVars=()=>{',
-        ...muteableVars.map((nm)=>`${nm} = lynx_runtime.__lynxGlobalBindingValues.${nm};`),
-        '};\n',
+        '"use strict";\n',
+        `(() => {const ${globalDisallowedVars.join('=void 0,')}=void 0;module.exports = `,
         content,
-        '\n return module.exports;}'
+        '\n})()'
     ].join('');
-async function generateJavascriptUrl(obj, injectVars, injectWithBind, muteableVars, globalDisallowedVars, createJsModuleUrl, isESM, templateName) {
+async function generateJavascriptUrl(obj, createJsModuleUrl, templateName) {
     const processEntry = async ([name, content])=>[
             name,
-            await createJsModuleUrl(generateModuleContent(content, injectVars.concat(muteableVars), injectWithBind, muteableVars, globalDisallowedVars, isESM), `${templateName}-${name.replaceAll('/', '')}.js`)
+            await createJsModuleUrl(generateModuleContent(content), `${templateName}-${name.replaceAll('/', '')}.js`)
         ];
     return Promise.all(Object.entries(obj).filter(([_, content])=>'string' == typeof content).map(processEntry)).then(Object.fromEntries);
 }
 async function generateTemplate(template, createJsModuleUrl, templateName) {
+    template.version = template.version ?? 1;
+    if (template.version > currentSupportedTemplateVersion) throw new Error("Unsupported template, please upgrade your web-platform dependencies");
+    let upgrader;
+    while(template.version < currentSupportedTemplateVersion && (upgrader = templateUpgraders[template.version - 1]))template = upgrader(template);
     return {
         ...template,
-        lepusCode: await generateJavascriptUrl(template.lepusCode, mainThreadInjectVars, [], globalMuteableVars, templateName ? [] : constants_globalDisallowedVars, createJsModuleUrl, true, templateName),
-        manifest: await generateJavascriptUrl(template.manifest, backgroundInjectVars, backgroundInjectWithBind, [], templateName ? [] : constants_globalDisallowedVars, createJsModuleUrl, false, templateName)
+        lepusCode: await generateJavascriptUrl(template.lepusCode, createJsModuleUrl, templateName),
+        manifest: await generateJavascriptUrl(template.manifest, createJsModuleUrl, templateName)
     };
 }
 function registerCallLepusMethodHandler(rpc, runtime) {
@@ -860,22 +787,32 @@ function registerGetCustomSectionHandler(rpc, customSections) {
     rpc.registerHandler(getCustomSectionsEndpoint, (key)=>customSections[key]?.content);
 }
 function createMainThreadLynx(config, SystemInfo) {
+    const requestAnimationFrameBrowserImpl = requestAnimationFrame;
+    const cancelAnimationFrameBrowserImpl = cancelAnimationFrame;
+    const setTimeoutBrowserImpl = setTimeout;
+    const clearTimeoutBrowserImpl = clearTimeout;
+    const setIntervalBrowserImpl = setInterval;
+    const clearIntervalBrowserImpl = clearInterval;
     return {
         getJSContext () {
             return config.jsContext;
         },
         requestAnimationFrame (cb) {
-            return requestAnimationFrame(cb);
+            return requestAnimationFrameBrowserImpl(cb);
         },
-        cancelAnimationFrame (handler1) {
-            return cancelAnimationFrame(handler1);
+        cancelAnimationFrame (handler) {
+            return cancelAnimationFrameBrowserImpl(handler);
         },
         __globalProps: config.globalProps,
         getCustomSectionSync (key) {
-            return config.customSections[key]?.content;
+            return config.lynxTemplate.customSections[key]?.content;
         },
         markPipelineTiming: config.callbacks.markTiming,
-        SystemInfo
+        SystemInfo,
+        setTimeout: setTimeoutBrowserImpl,
+        clearTimeout: clearTimeoutBrowserImpl,
+        setInterval: setIntervalBrowserImpl,
+        clearInterval: clearIntervalBrowserImpl
     };
 }
 const referenceTypes = async ()=>WebAssembly.validate(new Uint8Array([
@@ -1491,15 +1428,13 @@ const exposureRelatedAttributes = new Set([
 ]);
 function createMainThreadGlobalThis(config) {
     let timingFlags = [];
-    let renderPage;
-    const { callbacks, tagMap, pageConfig, lepusCode, rootDom, globalProps, styleInfo, ssrHydrateInfo, ssrHooks } = config;
+    const { callbacks, tagMap, pageConfig, lynxTemplate, rootDom, globalProps, styleInfo, ssrHydrateInfo, ssrHooks, mtsRealm, document } = config;
+    const { elementTemplate, lepusCode } = lynxTemplate;
     const lynxUniqueIdToElement = ssrHydrateInfo?.lynxUniqueIdToElement ?? [];
     const lynxUniqueIdToStyleRulesIndex = ssrHydrateInfo?.lynxUniqueIdToStyleRulesIndex ?? [];
     const elementToRuntimeInfoMap = new WeakMap();
     let pageElement = lynxUniqueIdToElement[1]?.deref();
     let uniqueIdInc = lynxUniqueIdToElement.length || 1;
-    const varsUpdateHandlers = [];
-    const lynxGlobalBindingValues = {};
     const exposureChangedElements = new Set();
     flattenStyleInfo(styleInfo, pageConfig.enableCSSSelector);
     transformToWebCss(styleInfo);
@@ -1507,7 +1442,7 @@ function createMainThreadGlobalThis(config) {
     let cardStyleElement;
     if (ssrHydrateInfo?.cardStyleElement) cardStyleElement = ssrHydrateInfo.cardStyleElement;
     else {
-        cardStyleElement = callbacks.createElement('style');
+        cardStyleElement = document.createElement('style');
         cardStyleElement.innerHTML = genCssContent(styleInfo, pageConfig);
         rootDom.append(cardStyleElement);
     }
@@ -1541,7 +1476,7 @@ function createMainThreadGlobalThis(config) {
             if (hname) {
                 crossThreadEvent.target.elementRefptr = event.target;
                 if (crossThreadEvent.currentTarget) crossThreadEvent.currentTarget.elementRefptr = event.currentTarget;
-                mtsGlobalThis.runWorklet?.(hname.value, [
+                mtsRealm.globalWindow.runWorklet?.(hname.value, [
                     crossThreadEvent
                 ]);
             }
@@ -1599,8 +1534,8 @@ function createMainThreadGlobalThis(config) {
         {
             eventName = eventName.toLowerCase();
             const isCapture = eventType.startsWith('capture');
-            const handler1 = isCapture ? runtimeInfo.eventHandlerMap[eventName]?.capture : runtimeInfo.eventHandlerMap[eventName]?.bind;
-            return handler1?.handler;
+            const handler = isCapture ? runtimeInfo.eventHandlerMap[eventName]?.capture : runtimeInfo.eventHandlerMap[eventName]?.bind;
+            return handler?.handler;
         }
     };
     const __GetEvents = (element)=>{
@@ -1610,11 +1545,11 @@ function createMainThreadGlobalThis(config) {
             info.bind,
             info.capture
         ])if (atomInfo) {
-            const { type, handler: handler1 } = atomInfo;
-            if (handler1) eventInfos.push({
+            const { type, handler } = atomInfo;
+            if (handler) eventInfos.push({
                 type: type,
                 name: lynxEventName,
-                function: handler1
+                function: handler
             });
         }
         return eventInfos;
@@ -1625,7 +1560,7 @@ function createMainThreadGlobalThis(config) {
     const __CreateElement = (tag, parentComponentUniqueId)=>{
         const uniqueId = uniqueIdInc++;
         const htmlTag = tagMap[tag] ?? tag;
-        const element = callbacks.createElement(htmlTag);
+        const element = document.createElement(htmlTag);
         lynxUniqueIdToElement[uniqueId] = new WeakRef(element);
         const parentComponentCssID = lynxUniqueIdToElement[parentComponentUniqueId]?.deref()?.getAttribute(cssIdAttribute);
         parentComponentCssID && '0' !== parentComponentCssID && element.setAttribute(cssIdAttribute, parentComponentCssID);
@@ -1706,7 +1641,7 @@ function createMainThreadGlobalThis(config) {
         elementToRuntimeInfoMap.set(element, runtimeInfo);
     };
     const __SwapElement = (childA, childB)=>{
-        const temp = callbacks.createElement('div');
+        const temp = document.createElement('div');
         childA.replaceWith(temp);
         childB.replaceWith(childA);
         temp.replaceWith(childB);
@@ -1730,12 +1665,13 @@ function createMainThreadGlobalThis(config) {
         updateCssOGStyle(Number(element.getAttribute(lynxUniqueIdAttribute)), newStyleStr ?? '');
     };
     const __LoadLepusChunk = (path)=>{
-        const lepusModule = lepusCode[`${path}`];
-        if (!lepusModule) return false;
-        {
-            const entry = lepusModule.exports;
-            entry?.(mtsGlobalThis);
+        try {
+            path = lepusCode?.[path] ?? path;
+            mtsRealm.loadScriptSync(path);
             return true;
+        } catch (e) {
+            console.error(`failed to load lepus chunk ${path}`, e);
+            return false;
         }
     };
     const __FlushElementTree = (_subTree, options)=>{
@@ -1775,14 +1711,14 @@ function createMainThreadGlobalThis(config) {
         }
     };
     const __ElementFromBinary = (templateId, parentComponentUniId)=>{
-        const elementTemplateData = config.elementTemplate[templateId];
+        const elementTemplateData = elementTemplate[templateId];
         if (elementTemplateData) {
             let clonedElements;
             if (templateIdToTemplate[templateId]) clonedElements = Array.from(templateIdToTemplate[templateId].content.cloneNode(true).children);
             else {
                 clonedElements = elementTemplateData.map((data)=>createElementForElementTemplateData(data, parentComponentUniId));
                 if (rootDom.cloneNode) {
-                    const template = callbacks.createElement('template');
+                    const template = document.createElement('template');
                     template.content.append(...clonedElements);
                     templateIdToTemplate[templateId] = template;
                     rootDom.append(template);
@@ -1870,42 +1806,23 @@ function createMainThreadGlobalThis(config) {
         _SetSourceMapRelease: (errInfo)=>release = errInfo?.release,
         __OnLifecycleEvent: callbacks.__OnLifecycleEvent,
         __FlushElementTree,
-        __lynxGlobalBindingValues: lynxGlobalBindingValues,
         _I18nResourceTranslation: callbacks._I18nResourceTranslation,
         _AddEventListener: ()=>{},
-        set _updateVars (handler){
-            varsUpdateHandlers.push(handler);
-        },
-        set renderPage (foo){
-            renderPage = foo;
-            queueMicrotask(callbacks.mainChunkReady);
-        },
-        get renderPage () {
-            return renderPage;
-        }
+        renderPage: void 0
     };
-    mtsGlobalThis.globalThis = new Proxy(mtsGlobalThis, {
-        get: (target, prop)=>{
-            if ('string' == typeof prop && constants_globalDisallowedVars.includes(prop)) return;
-            if ('globalThis' === prop) return target;
-            return target[prop] ?? globalThis[prop];
+    Object.assign(mtsRealm.globalWindow, mtsGlobalThis);
+    Object.defineProperty(mtsRealm.globalWindow, 'renderPage', {
+        get () {
+            return mtsGlobalThis.renderPage;
         },
-        set: (target, prop, value)=>{
-            target[prop] = value;
-            return true;
+        set (v) {
+            mtsGlobalThis.renderPage = v;
+            queueMicrotask(callbacks.mainChunkReady);
         },
-        ownKeys (target) {
-            return Reflect.ownKeys(target).filter((key)=>'globalThis' !== key);
-        }
+        configurable: true,
+        enumerable: true
     });
-    for (const nm of globalMuteableVars)Object.defineProperty(mtsGlobalThis, nm, {
-        get: ()=>lynxGlobalBindingValues[nm],
-        set: (v)=>{
-            lynxGlobalBindingValues[nm] = v;
-            for (const handler1 of varsUpdateHandlers)handler1();
-        }
-    });
-    return mtsGlobalThis;
+    return mtsRealm.globalWindow;
 }
 function createExposureService(rootDom, postExposure) {
     let working = true;
@@ -1966,8 +1883,7 @@ function createExposureService(rootDom, postExposure) {
     };
 }
 const initWasmPromise = initWasm();
-const moduleCache = {};
-function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, commitDocument, markTimingInternal, flushMarkTimingInternal, reportError, triggerI18nResourceFallback, initialI18nResources, ssrHooks) {
+function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, document, mtsRealm, commitDocument, markTimingInternal, flushMarkTimingInternal, reportError, triggerI18nResourceFallback, initialI18nResources, ssrHooks) {
     const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
     const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
     const publishEvent = backgroundThreadRpc.createCall(publishEventEndpoint);
@@ -1978,29 +1894,9 @@ function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, comm
     async function startMainThread(config, ssrHydrateInfo) {
         let isFp = true;
         const { globalProps, template, browserConfig, nativeModulesMap, napiModulesMap, tagMap, initI18nResources } = config;
-        const { styleInfo, pageConfig, customSections, cardType, lepusCode, elementTemplate } = template;
+        const { styleInfo, pageConfig, customSections, cardType } = template;
         markTimingInternal('decode_start');
         await initWasmPromise;
-        const lepusCodeEntries = await Promise.all(Object.entries(lepusCode).map(async ([name, url])=>{
-            const cachedModule = moduleCache[url];
-            if (cachedModule) return [
-                name,
-                cachedModule
-            ];
-            {
-                const { default: evaluateModule } = await import(url);
-                const module = {
-                    exports: evaluateModule
-                };
-                moduleCache[url] = module;
-                return [
-                    name,
-                    module
-                ];
-            }
-        }));
-        const lepusCodeLoaded = Object.fromEntries(lepusCodeEntries);
-        const entry = lepusCodeLoaded['root'].exports;
         const jsContext = new LynxCrossThreadContext({
             rpc: backgroundThreadRpc,
             receiveEventEndpoint: dispatchJSContextOnMainThreadEndpoint,
@@ -2008,18 +1904,18 @@ function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, comm
         });
         const i18nResources = initialI18nResources(initI18nResources);
         const mtsGlobalThis = createMainThreadGlobalThis({
+            lynxTemplate: template,
+            mtsRealm,
             jsContext,
             tagMap,
             browserConfig,
-            customSections,
-            elementTemplate,
             globalProps,
             pageConfig,
             styleInfo,
-            lepusCode: lepusCodeLoaded,
             rootDom,
             ssrHydrateInfo,
             ssrHooks,
+            document,
             callbacks: {
                 mainChunkReady: ()=>{
                     markTimingInternal('data_processor_start');
@@ -2085,7 +1981,6 @@ function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, comm
                 markTiming: (a, b)=>markTimingInternal(b, a),
                 publishEvent,
                 publicComponentEvent,
-                createElement,
                 _I18nResourceTranslation: (options)=>{
                     const matchedInitI18nResources = i18nResources.data?.find((i)=>getCacheI18nResourcesKey(i.options) === getCacheI18nResourcesKey(options));
                     dispatchI18nResource(matchedInitI18nResources?.resource);
@@ -2095,9 +1990,8 @@ function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, createElement, comm
             }
         });
         markTimingInternal('decode_end');
-        entry(mtsGlobalThis);
+        await mtsRealm.loadScript(template.lepusCode.root);
         jsContext.__start();
-        return mtsGlobalThis;
     }
     return {
         startMainThread
@@ -2808,7 +2702,39 @@ async function createLynxView(config) {
     });
     const i18nResources = new I18nResources();
     const events = [];
-    const { startMainThread } = prepareMainThreadAPIs(backgroundThreadRpc, offscreenDocument, offscreenDocument.createElement.bind(offscreenDocument), ()=>{
+    const mtsVMContext = node_vm.createContext(node_vm.constants.DONT_CONTEXTIFY);
+    Object.assign(mtsVMContext, {
+        document: offscreenDocument,
+        module: {
+            exports: null
+        }
+    });
+    const loadScriptSync = (url)=>{
+        const scriptContent = node_fs.readFileSync(url);
+        const script = new node_vm.Script(scriptContent.toString(), {
+            filename: url
+        });
+        return script.runInContext(mtsVMContext);
+    };
+    const loadScript = async (url)=>new Promise((resolve, reject)=>{
+            node_fs.readFile(url, (err, data)=>{
+                if (err) return void reject(err);
+                try {
+                    const script = new node_vm.Script(data.toString(), {
+                        filename: url
+                    });
+                    const result = script.runInContext(mtsVMContext);
+                    resolve(result);
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    const { startMainThread } = prepareMainThreadAPIs(backgroundThreadRpc, offscreenDocument, offscreenDocument, {
+        globalWindow: mtsVMContext,
+        loadScript,
+        loadScriptSync
+    }, ()=>{
         firstPaintReady();
     }, ()=>{}, ()=>{}, ()=>{}, ()=>{}, (initI18nResources)=>{
         i18nResources.setData(initI18nResources);
@@ -2823,7 +2749,7 @@ async function createLynxView(config) {
             ]);
         }
     });
-    const runtime = await startMainThread({
+    await startMainThread({
         template,
         initData,
         globalProps,
@@ -2842,7 +2768,7 @@ async function createLynxView(config) {
     };
     async function renderToString() {
         await firstPaintReadyPromise;
-        const ssrEncodeData = runtime?.ssrEncode?.();
+        const ssrEncodeData = mtsVMContext?.ssrEncode?.();
         const ssrDumpInfo = {
             ssrEncodeData,
             events

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-core-server-canary",
-  "version": "0.15.8-canary-20250828-86da1623",
+  "version": "0.16.0-canary-20250828-c1f8715a",
   "private": false,
   "description": "",
   "keywords": [],
@@ -25,11 +25,11 @@
   "devDependencies": {
     "rsbuild-plugin-arethetypeswrong": "0.1.1",
     "rsbuild-plugin-publint": "0.3.3",
-    "@lynx-js/web-constants": "npm:@lynx-js/web-constants-canary@0.15.8-canary-20250828-86da1623",
     "@lynx-js/offscreen-document": "npm:@lynx-js/offscreen-document-canary@0.1.3",
+    "@lynx-js/web-constants": "npm:@lynx-js/web-constants-canary@0.16.0-canary-20250828-c1f8715a",
     "@lynx-js/web-elements-template": "npm:@lynx-js/web-elements-template-canary@0.8.4",
-    "@lynx-js/web-mainthread-apis": "npm:@lynx-js/web-mainthread-apis-canary@0.15.8-canary-20250828-86da1623",
-    "@lynx-js/web-worker-rpc": "npm:@lynx-js/web-worker-rpc-canary@0.15.8-canary-20250828-86da1623"
+    "@lynx-js/web-worker-rpc": "npm:@lynx-js/web-worker-rpc-canary@0.16.0-canary-20250828-c1f8715a",
+    "@lynx-js/web-mainthread-apis": "npm:@lynx-js/web-mainthread-apis-canary@0.16.0-canary-20250828-c1f8715a"
   },
   "scripts": {
     "build": "rslib build",