@withl5e/l5e 1.1.0-alpha.1 → 1.1.0-alpha.2

package/dist/vite-plugin.js

@@ -1,2 +1,2 @@
-import { t as e } from "./vite-plugin-R3LFxv9a.js";
+import { t as e } from "./vite-plugin-BOuzxmb2.js";
 export { e as coreVite, e as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withl5e/l5e",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0-alpha.2",
   "description": "HTML-first SSR MPA framework with loaders, middleware, islands, actions, swap, SEO and cache controls.",
   "type": "module",
   "license": "MIT",

package/src/core/bundler.ts

@@ -47,10 +47,12 @@ export interface ScriptBundleOptions {
   compact?: boolean;
   islands?: Array<{ key: string; script: string }>;
   renderer?: string;
-  name?: 'global' | 'bundle' | 'shared';
+  name?: 'global' | 'bundle' | 'shared' | 'renderer' | 'island';
+  inlineStaticRootClosure?: boolean;
   sharedUrl?: string;
   globalUrl?: string;
   exportScripts?: string[];
+  externalScripts?: Record<string, string>;
 }
 
 const EMPTY_RESULT: BundleResult = { hash: '', filename: '', content: '' };
@@ -134,6 +136,8 @@ function compactBuildPlugin(
   policy: ScriptBundlePolicy,
   sharedUrl?: string,
   globalUrl?: string,
+  eagerFiles = new Set<string>(),
+  externalFiles = new Map<string, string>(),
 ): Plugin {
   return {
     name: 'compact-build-graph',
@@ -147,10 +151,14 @@ function compactBuildPlugin(
           ? path.resolve(path.dirname(importer), source)
           : null;
       if (!file) return null;
-      return policy.isShared(file) && sharedUrl
+      return externalFiles.has(file)
+        ? { id: externalFiles.get(file)!, external: 'absolute' }
+        : policy.isShared(file) && sharedUrl
         ? { id: sharedUrl, external: 'absolute' }
         : policy.isGlobalOwned(file) && globalUrl
           ? { id: globalUrl, external: 'absolute' }
+          : policy.isLazy(file) && !eagerFiles.has(file)
+            ? { id: policy.assetUrl(file), external: 'absolute' }
         : { id: file };
     },
   };
@@ -175,23 +183,26 @@ async function runScriptBundle(
   }));
   const renderer = options.renderer ? policy.fileForScript(options.renderer) : undefined;
   const exportFiles = (options.exportScripts || []).map((script) => policy.fileForScript(script));
+  const eagerFiles = options.inlineStaticRootClosure
+    ? policy.staticClosure(roots)
+    : new Set<string>();
+  const externalFiles = new Map(
+    Object.entries(options.externalScripts || {}).map(([script, url]) => [
+      policy.fileForScript(script),
+      url,
+    ]),
+  );
   const entryContent = [
     ...roots.map((filePath) =>
-      options.name === 'shared'
+      options.name === 'renderer'
+        ? `export { createElement, reactDomClient } from ${JSON.stringify(filePath)};`
+        : options.name === 'island'
+          ? `import * as __island from ${JSON.stringify(filePath)}; export * from ${JSON.stringify(filePath)}; export default __island.default;`
+        : options.name === 'shared'
         ? `export * from ${JSON.stringify(filePath)};`
         : `import ${JSON.stringify(filePath)};`,
     ),
     ...exportFiles.map((filePath) => `export * from ${JSON.stringify(filePath)};`),
-    ...(islands.length
-      ? [
-          'globalThis.__L5E_ISLANDS__ ||= {};',
-          ...islands.map(
-            ({ key, file }) =>
-              `globalThis.__L5E_ISLANDS__[${JSON.stringify(key)}] = async () => { const [renderer, module] = await Promise.all([import(${JSON.stringify(renderer)}), import(${JSON.stringify(file)})]); return { reactDomClient: renderer.reactDomClient, createElement: renderer.createElement, module }; };`,
-          ),
-          'globalThis.__L5E_BOOT_ISLANDS__?.();',
-        ]
-      : []),
   ].join('\n');
 
   const rolldownOptions: InputOptions = {
@@ -199,7 +210,7 @@ async function runScriptBundle(
     plugins: [
       virtualEntryPlugin(entryContent),
       compact
-        ? compactBuildPlugin(policy, options.sharedUrl, options.globalUrl)
+        ? compactBuildPlugin(policy, options.sharedUrl, options.globalUrl, eagerFiles, externalFiles)
         : preserveBuildChunksPlugin(policy),
     ],
     platform: 'neutral',
@@ -244,9 +255,10 @@ async function runScriptBundle(
     if (chunk.type !== 'chunk') {
       continue;
     }
+    const code = (chunk.code || '').replace(/^\/\/#(?:end)?region[^\r\n]*(?:\r?\n)?/gm, '');
     bundledFilesMap.set(chunk.fileName, {
-      content: chunk.code || '',
-      hash: generateHash(chunk.code || ''),
+      content: code,
+      hash: generateHash(code),
       filename: chunk.fileName,
       mimeType: 'application/javascript',
     });
@@ -259,11 +271,12 @@ async function runScriptBundle(
   if (!entryChunk) {
     throw new Error('[bundler] rolldown produced no entry chunk');
   }
+  const entryFile = bundledFilesMap.get(entryChunk.fileName)!;
 
   return {
-    hash: generateHash(entryChunk.code || ''),
+    hash: entryFile.hash,
     filename: entryChunk.fileName,
-    content: entryChunk.code || '',
+    content: entryFile.content,
   };
 }
 

package/src/core/chunking.ts

@@ -20,6 +20,8 @@ export interface ChunkingOptions {
    */
   mode?: 'compact';
   shared?: SharedChunkGroup[];
+  /** Static UI/runtime roots that join React's canonical lazy activation chunk. */
+  islandRuntime?: Pick<SharedChunkGroup, 'packages' | 'modules'>;
 }
 
 export interface CoreViteOptions {
@@ -43,6 +45,14 @@ type Decision = { group: string | null; rule?: string; consumers: string[]; reas
 /** One build-time plan drives placement and the diagnostic report. Runtime reads Vite's manifest. */
 export function createChunkPlanner(options: ChunkingOptions = {}) {
   const rules = options.shared || [];
+  const islandRuntimeRule = options.islandRuntime;
+  if (
+    islandRuntimeRule &&
+    !islandRuntimeRule.packages?.length &&
+    !islandRuntimeRule.modules?.length
+  ) {
+    throw new Error('[l5e chunking] islandRuntime needs packages or modules.');
+  }
   if (options.mode === 'compact' && rules.length > 1) {
     throw new Error('[l5e chunking] Compact mode accepts one canonical shared group.');
   }
@@ -66,6 +76,7 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
   }
   let root = '';
   const resolvedRules = new Map<SharedChunkGroup, Set<string>>();
+  let resolvedIslandRuntime = new Set<string>();
   const decisions = new Map<string, Decision>();
   const warnings = new Set<string>();
   const portable = (id: string) => {
@@ -81,6 +92,7 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
     ) {
       root = projectRoot;
       resolvedRules.clear();
+      resolvedIslandRuntime = new Set();
       decisions.clear();
       warnings.clear();
       for (const rule of rules) {
@@ -92,6 +104,13 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
         }
         resolvedRules.set(rule, ids);
       }
+      if (islandRuntimeRule) {
+        for (const specifier of islandRuntimeRule.modules || []) {
+          const id = await resolveId(specifier, path.join(root, 'index.html'));
+          if (!id) throw new Error(`[l5e chunking] Cannot resolve ${specifier} in islandRuntime`);
+          resolvedIslandRuntime.add(id);
+        }
+      }
     },
     analyze(modules: ModuleInfo[]) {
       decisions.clear();
@@ -149,6 +168,7 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
         const mod = graph.get(id)!;
         if (!mod.isEntry) return 3;
         if (normalize(id).endsWith('/src/client.global.ts')) return 0;
+        if (normalize(id).includes('virtual:l5e-compact-renderer')) return 2;
         if (/\/react\//.test(normalize(id)) && !packageName(id)) return 2;
         return 1;
       };
@@ -170,7 +190,26 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
           );
         let group: string | null = null;
         let reason = 'Private dependency stays with its entry or dynamic import.';
-        if (!mod.isEntry && users.length && matches.length) {
+        const pkg = packageName(mod.id);
+        const islandRuntimeMatch =
+          resolvedIslandRuntime.has(mod.id) ||
+          islandRuntimeRule?.packages?.includes(pkg || '') === true;
+        if (
+          options.mode === 'compact' &&
+          normalize(mod.id).includes('virtual:l5e-compact-renderer')
+        ) {
+          group = 'lazy-react-runtime';
+          reason = 'Renderer joins the canonical React runtime activation.';
+        } else if (
+          options.mode === 'compact' &&
+          !mod.isEntry &&
+          (pkg === 'react' || pkg === 'react-dom' || pkg === 'scheduler') &&
+          users.length > 0 &&
+          users.every((id) => rank(id) >= 2)
+        ) {
+          group = 'lazy-react-runtime';
+          reason = 'Canonical React runtime is fetched when the first island activates.';
+        } else if (!mod.isEntry && users.length && matches.length) {
           // Explicit groups can combine consumers at the same activation tier.
           // Never promote island-only code into global/page, or dynamic-only code
           // into a static entry. Distinct dynamic roots remain separate as well.
@@ -181,6 +220,9 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
               : ['global', 'page', 'island'][tier];
           group = options.mode === 'compact' ? 'shared' : `shared-${matches[0].name}-${activation}`;
           reason = `Configured group ${matches[0].name}; activation ${activation}.`;
+        } else if (options.mode === 'compact' && !mod.isEntry && islandRuntimeMatch) {
+          group = 'lazy-react-runtime';
+          reason = 'Configured canonical island runtime is fetched with the first island consumer.';
         } else if (
           options.mode === 'compact' &&
           !mod.isEntry &&
@@ -212,7 +254,15 @@ export function createChunkPlanner(options: ChunkingOptions = {}) {
           includeDependenciesRecursively: options.mode === 'compact',
         })),
         {
-          name: (id: string) => decisions.get(id)?.group || null,
+          name: (id: string) =>
+            decisions.get(id)?.group === 'lazy-react-runtime' ? 'lazy-react-runtime' : null,
+          includeDependenciesRecursively: true,
+        },
+        {
+          name: (id: string) => {
+            const group = decisions.get(id)?.group;
+            return group === 'lazy-react-runtime' ? null : group || null;
+          },
           includeDependenciesRecursively: false,
         },
       ];

package/src/core/script-bundle-policy.ts

@@ -28,6 +28,7 @@ export function createScriptBundlePolicy(
   const files = new Set<string>();
   const preserved = new Set<string>();
   const staticImports = new Map<string, string[]>();
+  const lazy = new Set<string>();
   const jsEntries = Object.entries(manifest).filter(([, entry]) => /\.[cm]?js$/.test(entry.file));
 
   function absoluteFile(file: string) {
@@ -83,6 +84,34 @@ export function createScriptBundlePolicy(
     );
   }
 
+
+  // A runtime page bundle keeps dynamic roots and their static closure as emitted
+  // assets. This preserves download/init boundaries while allowing the page's
+  // transformed preload helper to start the known closure in parallel.
+  const staticallyInitial = new Set<string>();
+  const visitInitial = (key: string) => {
+    const entry = manifest[key];
+    if (!entry || !/\.[cm]?js$/.test(entry.file)) return;
+    const file = absoluteFile(entry.file);
+    if (staticallyInitial.has(file)) return;
+    staticallyInitial.add(file);
+    for (const dependency of entry.imports || []) visitInitial(dependency);
+  };
+  for (const [key, entry] of jsEntries) {
+    if (entry.isEntry && !entry.isDynamicEntry) visitInitial(key);
+  }
+  const visitLazy = (key: string) => {
+    const entry = manifest[key];
+    if (!entry || !/\.[cm]?js$/.test(entry.file)) return;
+    const file = absoluteFile(entry.file);
+    if (lazy.has(file) || staticallyInitial.has(file)) return;
+    lazy.add(file);
+    for (const dependency of entry.imports || []) visitLazy(dependency);
+  };
+  for (const [, entry] of jsEntries) {
+    for (const key of entry.dynamicImports || []) visitLazy(key);
+  }
+
   const cacheKey = createHash('sha256')
     .update(JSON.stringify([directory, assetDirectory, base, manifest]))
     .digest('hex');
@@ -117,6 +146,19 @@ export function createScriptBundlePolicy(
     isGlobalOwned(file: string) {
       return globalOwned.has(file);
     },
+    isLazy(file: string) {
+      return lazy.has(file);
+    },
+    staticClosure(roots: string[]) {
+      const closure = new Set<string>();
+      const visit = (file: string) => {
+        if (closure.has(file)) return;
+        closure.add(file);
+        for (const dependency of staticImports.get(file) || []) visit(dependency);
+      };
+      roots.forEach(visit);
+      return closure;
+    },
     sharedScripts() {
       return [...shared].map((file) =>
         withAssetBase(base, path.relative(assetDirectory, file).replace(/\\/g, '/')),

package/src/core/server.ts

@@ -321,6 +321,18 @@ async function createPageResponse({
         compactGlobalUrl = withAssetBase(assetBase, bundledGlobal.filename);
         globalScripts.push(compactGlobalUrl);
       }
+      const imports: Record<string, string> = {};
+      if (compactSharedUrl) {
+        for (const original of sharedScripts) imports[original] = compactSharedUrl;
+      }
+      if (compactGlobalUrl) {
+        for (const original of scriptPolicy.globalOwnedScripts()) {
+          imports[original] = compactGlobalUrl;
+        }
+      }
+      if (Object.keys(imports).length > 0) {
+        extraHead += `<script type="importmap">${serialize({ imports })}</script>`;
+      }
     }
     scriptSrcList = scriptSrcList.filter(
       (src) => src.replace(/^\//, '') !== 'src/client.global.ts',
@@ -345,6 +357,28 @@ async function createPageResponse({
       return { file: entry.file };
     }
 
+    function activationPlan(entryKeys: string[], excluded = new Set<string>()) {
+      const js = new Set<string>();
+      const css = new Set<string>();
+      const visited = new Set<string>();
+      const visit = (entryKey: string) => {
+        if (visited.has(entryKey)) return;
+        visited.add(entryKey);
+        const entry = manifest![entryKey];
+        if (!entry) return;
+        for (const file of entry.css || []) css.add(withAssetBase(assetBase, file));
+        if (!excluded.has(entryKey) && entry.file && /\.[cm]?js$/.test(entry.file)) {
+          const absolute = scriptPolicy!.fileForScript(`/${entry.file}`);
+          if (!scriptPolicy!.isShared(absolute) && !scriptPolicy!.isGlobalOwned(absolute)) {
+            js.add(withAssetBase(assetBase, entry.file));
+          }
+        }
+        for (const dependency of entry.imports || []) visit(dependency);
+      };
+      entryKeys.forEach(visit);
+      return { js: [...js], css: [...css] };
+    }
+
     const mappedScripts: string[] = [];
     for (const src of scriptSrcList) {
       const entryKey = src.replace(/^\//, '');
@@ -362,26 +396,11 @@ async function createPageResponse({
       }
     }
 
-    if (mappedScripts.length > 0 || (scriptPolicy?.compact && islandEntries.length > 0)) {
-      const compactIslands = scriptPolicy?.compact
-        ? islandEntries.flatMap((island) => {
-            const entry = manifest[island.src];
-            return entry?.file ? [{ key: island.key, script: `/${entry.file}` }] : [];
-          })
-        : [];
-      const compactRenderer = scriptPolicy?.compact
-        ? Object.entries(manifest).find(([key]) => key.includes('l5e-compact-renderer'))?.[1]
-            ?.file
-        : undefined;
-      if (scriptPolicy?.compact && compactIslands.length > 0 && !compactRenderer) {
-        throw new Error('[l5e chunking] Compact renderer entry is missing from the manifest.');
-      }
+    if (mappedScripts.length > 0) {
       const bundledScript = await bundleScripts(mappedScripts, distClientDir, scriptPolicy, {
         compact: scriptPolicy?.compact,
-        islands: compactIslands,
         name: 'bundle',
         sharedUrl: compactSharedUrl,
-        renderer: compactRenderer ? `/${compactRenderer}` : undefined,
         globalUrl: compactGlobalUrl,
       });
       scriptSrcList = bundledScript.filename
@@ -389,6 +408,86 @@ async function createPageResponse({
         : mappedScripts.map((file) => withAssetBase(assetBase, file));
     }
 
+    if (scriptPolicy?.compact && islandEntries.length > 0) {
+      const rendererEntry = Object.entries(manifest).find(
+        ([key, entry]) => entry.isEntry && key.includes('l5e-compact-renderer'),
+      );
+      if (!rendererEntry?.[1].file) {
+        throw new Error('[l5e chunking] Compact renderer entry is missing from the manifest.');
+      }
+      const rendererOwnedKeys = new Set<string>();
+      rendererOwnedKeys.add(rendererEntry[0]);
+      const rendererDependencies = (rendererEntry[1].imports || []).filter((dependency: string) =>
+        manifest[dependency]?.file?.includes('compact-renderer'),
+      );
+      if (rendererDependencies.length !== 1) {
+        throw new Error(
+          `[l5e chunking] Compact renderer expected one canonical export chunk; found ${rendererDependencies.length}. Multiple chunks can have colliding emitted export aliases.`,
+        );
+      }
+      rendererOwnedKeys.add(rendererDependencies[0]);
+      const bundledRenderer = await bundleScripts(
+        [`/${rendererEntry[1].file}`],
+        distClientDir,
+        scriptPolicy,
+        {
+          compact: true,
+          name: 'renderer',
+          sharedUrl: compactSharedUrl,
+          globalUrl: compactGlobalUrl,
+          inlineStaticRootClosure: true,
+          exportScripts: [...rendererOwnedKeys]
+            .filter((key) => key !== rendererEntry[0])
+            .map((key) => `/${manifest[key].file}`),
+        },
+      );
+      if (!bundledRenderer.filename) {
+        throw new Error('[l5e chunking] Compact renderer bundle failed.');
+      }
+      const rendererUrl = withAssetBase(assetBase, bundledRenderer.filename);
+      const rendererAliases = Object.fromEntries(
+        [...rendererOwnedKeys]
+          .filter((key) => manifest[key]?.file)
+          .map((key) => [`/${manifest[key].file}`, rendererUrl]),
+      );
+      const rendererImports = Object.fromEntries(
+        [...rendererOwnedKeys]
+          .filter((key) => manifest[key]?.file)
+          .map((key) => [withAssetBase(assetBase, manifest[key].file), rendererUrl]),
+      );
+      if (Object.keys(rendererImports).length > 0) {
+        extraHead += `<script type="importmap">${serialize({ imports: rendererImports })}</script>`;
+      }
+      const islandMap: Record<
+        string,
+        { module: string; renderer: string; js: string[]; css: string[] }
+      > = {};
+      for (const island of islandEntries) {
+        const entry = manifest[island.src];
+        if (!entry?.file) continue;
+        const bundledIsland = await bundleScripts([`/${entry.file}`], distClientDir, scriptPolicy, {
+          compact: true,
+          name: 'island',
+          sharedUrl: compactSharedUrl,
+          globalUrl: compactGlobalUrl,
+          inlineStaticRootClosure: true,
+          externalScripts: rendererAliases,
+        });
+        if (!bundledIsland.filename) {
+          throw new Error(`[l5e chunking] Compact island bundle failed: ${island.src}`);
+        }
+        const islandUrl = withAssetBase(assetBase, bundledIsland.filename);
+        const plan = activationPlan([island.src], rendererOwnedKeys);
+        islandMap[island.key] = {
+          module: islandUrl,
+          renderer: rendererUrl,
+          js: [rendererUrl, islandUrl],
+          css: plan.css,
+        };
+      }
+      islandRegistryScript = `<script>Object.assign(window.__L5E_ISLANDS__||={},${serialize(islandMap)});window.__L5E_BOOT_ISLANDS__?.()</script>`;
+    }
+
     if (cssFiles.size > 0) {
       const bundledCss = await bundleCss(
         [...cssFiles].map((file) => `/${file}`),
@@ -616,6 +715,8 @@ export async function createServer(options: ServerOptions = {}): Promise<ServerC
         withAssetBase(base, 'global-:hash.:ext'),
         withAssetBase(base, 'bundle-:hash.:ext'),
         withAssetBase(base, 'shared-:hash.:ext'),
+        withAssetBase(base, 'renderer-:hash.:ext'),
+        withAssetBase(base, 'island-:hash.:ext'),
       ],
       async (req: ExpressRequest, res: ExpressResponse) => {
         try {

package/src/core/vite-plugin.ts

@@ -585,8 +585,16 @@ export function coreVite(options: CoreViteOptions = {}): Plugin {
           ...(options.chunking && options.chunking.mode === 'compact'
             ? {
                 modulePreload: {
-                  resolveDependencies: (_filename: string, dependencies: string[]) =>
-                    dependencies.filter((dependency) => !/\.[cm]?js(?:\?|$)/.test(dependency)),
+                  resolveDependencies: (
+                    _filename: string,
+                    dependencies: string[],
+                    context: { hostType: 'html' | 'js' },
+                  ) =>
+                    context.hostType === 'html'
+                      ? dependencies.filter(
+                          (dependency) => !/\.[cm]?js(?:\?|$)/.test(dependency),
+                        )
+                      : dependencies,
                 },
               }
             : {}),
@@ -618,6 +626,8 @@ export function coreVite(options: CoreViteOptions = {}): Plugin {
                         ? 'assets/[name]-[hash].js'
                         : chunk.name === 'shared'
                           ? 'assets/shared-[hash].js'
+                          : chunk.name === 'lazy-react-runtime'
+                            ? 'assets/lazy-react-runtime-[hash].js'
                         : chunk.isDynamicEntry
                           ? 'assets/bundle-[name]-[hash].js'
                           : 'assets/shared-[name]-[hash].js',

package/src/island/compact-runtime.ts

@@ -41,8 +41,8 @@ type CompactIslandModule = {
   createElement: typeof import('react').createElement;
   module: Record<string, any>;
 };
-const registry: Record<string, () => Promise<CompactIslandModule>> = ((window as any)
-  .__L5E_ISLANDS__ ||= {});
+type CompactIslandPlan = { module: string; renderer: string; js: string[]; css: string[] };
+const registry: Record<string, CompactIslandPlan> = ((window as any).__L5E_ISLANDS__ ||= {});
 let islandData: unknown[] | null = null;
 const scheduled = new WeakSet<Element>();
 
@@ -79,13 +79,51 @@ function mount(island: IslandMeta) {
   return async () => {
     if (mounted) return;
     mounted = true;
-    const loader = registry[island.registryKey];
-    if (!loader) {
+    const plan = registry[island.registryKey];
+    if (!plan) {
       console.error(`[l5e-island] Component "${island.registryKey}" not found in page registry.`);
       return;
     }
     try {
-      const { reactDomClient, createElement, module } = await loader();
+      // Schedule the complete known static closure before awaiting any response.
+      // Modulepreload fetches without evaluating; native import retains ESM order.
+      for (const href of plan.js) {
+        if (document.querySelector(`link[rel="modulepreload"][href="${CSS.escape(href)}"]`))
+          continue;
+        const link = document.createElement('link');
+        link.rel = 'modulepreload';
+        link.crossOrigin = 'anonymous';
+        link.href = href;
+        document.head.append(link);
+      }
+      await Promise.all(
+        plan.css.map(
+          (href) =>
+            new Promise<void>((resolve, reject) => {
+              const existing = document.querySelector<HTMLLinkElement>(
+                `link[rel="stylesheet"][href="${CSS.escape(href)}"]`,
+              );
+              if (existing?.sheet) return resolve();
+              const link = existing || document.createElement('link');
+              link.rel = 'stylesheet';
+              link.crossOrigin = 'anonymous';
+              link.href = href;
+              link.addEventListener('load', () => resolve(), { once: true });
+              link.addEventListener('error', () => reject(new Error(`Failed to load ${href}`)), {
+                once: true,
+              });
+              if (!existing) document.head.append(link);
+            }),
+        ),
+      );
+      const [renderer, module] = await Promise.all([
+        import(/* @vite-ignore */ plan.renderer),
+        import(/* @vite-ignore */ plan.module),
+      ]);
+      const { reactDomClient, createElement } = renderer as Omit<
+        CompactIslandModule,
+        'module'
+      >;
       const Component = module.default || module[island.exportName];
       if (!Component) throw new Error(`No export "default" or "${island.exportName}" in module`);
       if (island.ssr) {
@@ -103,8 +141,7 @@ function mount(island: IslandMeta) {
 function boot() {
   for (const island of discover()) {
     if (scheduled.has(island.element)) continue;
-    // The compact global can execute before the page bundle registers its loaders.
-    // The page bundle calls boot again after registration.
+    // A fragment swap can expose an element before its activation plan is installed.
     if (!registry[island.registryKey]) continue;
     const strategy = strategies.get(island.mount);
     if (!strategy) {