fix(lynx): embed native main-thread container

Author: ScriptedAlchemy

.changeset/tiny-lynxes-federate.md

@@ -16,6 +16,8 @@ plugin releases that preserve automatic public paths, expose retryable lazy
 loading, and omit assetless remote-only chunk groups.
 Bootstrap the ReactLynx lazy-bundle loader before federation async startup so
 initial shared chunks use FetchBundle instead of the legacy component loader.
+Embed the paired container entry in native split remotes so fetched main-thread
+chunks install their snapshot factories before React commits them.
 Accept the cache-events plugin 0.2 line used by Rspeedy 0.16.
 
 Resolve manifest `publicPath: 'auto'` from the fetched response URL so

apps/lynx-module-federation-demo/test/native-artifacts.mjs

@@ -94,7 +94,17 @@ assert.equal(standaloneTemplate['app-type'], 'card');
 assert.equal(standaloneTemplate['engine-version'], '3.9');
 assert.equal(remoteTemplate['app-type'], 'DynamicComponent');
 assert.equal(remoteTemplate['engine-version'], '3.9');
-assert.deepEqual(Object.keys(remoteTemplate['custom-sections']), ['catalog']);
+assert.deepEqual(Object.keys(remoteTemplate['custom-sections']).sort(), [
+  'catalog',
+  'catalog__main-thread',
+]);
+const remoteMainThreadEntry = Buffer.from(
+  remoteTemplate['custom-sections']['catalog__main-thread'],
+);
+assert.ok(
+  remoteMainThreadEntry.includes(Buffer.from('processEvalResultByHost')),
+  'native remote has no main-thread chunk installer',
+);
 const hostBackgroundSource = hostTemplate['background-thread-script']
   .map(({ content }) => content)
   .join('\n');

packages/lynx/src/plugin.remoteBundle.test.ts

@@ -393,7 +393,7 @@ describe('pluginLynxModuleFederation remote bundles', () => {
     expect(encoder.options).toMatchObject({
       bundleFileName: 'catalog-native.lynx.bundle',
       engineVersion: '3.6',
-      entryAssets: ['catalog.js'],
+      entryAssets: ['catalog.js', 'catalog__main-thread.js'],
       stateStore: { for: expect.any(Function) },
     });
     expect(encoder.options.encode).toBeTypeOf('function');

packages/lynx/src/remoteBundle.ts

@@ -50,7 +50,7 @@ type RemoteBundlePlan = RemoteBundlePlanBase &
     | {
         chunking: 'split';
         mainThreadChunkPrefix: string;
-        mainThreadEntry: undefined;
+        mainThreadEntry: string;
         mode: 'native-split';
       }
     | {
@@ -122,8 +122,8 @@ const normalizeRemoteBundlePlan = (
     includedChunkPrefixes: [backgroundChunkPrefix, mainThreadChunkPrefix],
     mainThreadChunkPrefix,
   };
+  const mainThreadEntry = `${outputName}__main-thread.js`;
   if (remoteBundle.target === 'web') {
-    const mainThreadEntry = `${outputName}__main-thread.js`;
     return {
       ...splitPlan,
       entryAssets: [backgroundEntry, mainThreadEntry],
@@ -134,8 +134,8 @@ const normalizeRemoteBundlePlan = (
 
   return {
     ...splitPlan,
-    entryAssets: [backgroundEntry],
-    mainThreadEntry: undefined,
+    entryAssets: [backgroundEntry, mainThreadEntry],
+    mainThreadEntry,
     mode: 'native-split',
   };
 };

packages/lynx/src/runtimeEntryLoader.ts

@@ -71,7 +71,17 @@ const preparePairedMainThreadEntry = (
           entry,
           sectionPath: `${entryGlobalName}__main-thread`,
         },
-        () => resolve(),
+        (result: unknown) => {
+          if (result === false) {
+            reject(
+              new Error(
+                `Lynx remote bundle "${entryGlobalName}" did not expose its paired main-thread entry.`,
+              ),
+            );
+            return;
+          }
+          resolve();
+        },
       );
     } catch (error) {
       reject(error);

packages/lynx/src/runtimePlugin.test.ts

@@ -236,6 +236,32 @@ describe('lynxRuntimePlugin entry loading', () => {
     expect(registry.size).toBe(0);
   });
 
+  it('rejects a remote whose paired main-thread entry is missing', async () => {
+    const registry = new Map<string, string>();
+    (
+      globalThis as unknown as Record<
+        PropertyKey,
+        Map<string, string> | undefined
+      >
+    )[LYNX_BUNDLE_REGISTRY] = registry;
+    setLynx({
+      fetchBundle: async () => ({ code: 0, url: 'lynx-cache://remote' }),
+      getNativeApp: () => ({
+        callLepusMethod: (
+          _name: string,
+          _payload: unknown,
+          callback: (result: boolean) => void,
+        ) => callback(false),
+      }),
+      loadScript: () => createContainer(),
+    });
+
+    await expect(
+      loadEntry(lynxRuntimePlugin(), bundleRemoteInfo),
+    ).rejects.toThrow('did not expose its paired main-thread entry');
+    expect(registry.size).toBe(0);
+  });
+
   it('loads bundle entries from the main-thread section', async () => {
     const container = createContainer();
     const globalRecord = globalThis as unknown as Record<string, unknown>;