@lwrjs/view-registry 0.10.0-alpha.13 → 0.10.0-alpha.14

package/build/es/linkers/preload-utils.js

@@ -0,0 +1,70 @@
+import { explodeSpecifier, getGroupName, getVersionedModuleId, normalizeVersionToUri, logger, VERSION_NOT_PROVIDED, getSpecifier, isGroupie, } from '@lwrjs/shared-utils';
+/**
+ * keeps track of preloadModules metadata
+ */
+export function setPreloadModulesMeta(specifier, uri, groups, preloads) {
+    const preloadModulesSpecifiers = preloads.specifiers;
+    const preloadBundleGroupsMap = preloads.groups;
+    const preloadModulesURIs = preloads.uris;
+    preloadModulesSpecifiers.push(specifier);
+    const { specifier: unversionedSpecifier } = explodeSpecifier(specifier);
+    const groupName = getGroupName(unversionedSpecifier, groups);
+    if (groupName && preloadBundleGroupsMap.has(groupName)) {
+        return;
+    }
+    // With bundling groups, we only want to include one URI
+    preloadModulesURIs.push(uri);
+    groupName && preloadBundleGroupsMap.set(groupName, true);
+}
+/**
+ * Recursively gets preloadModules metadata starting with a specifer
+ * Note: don't call me unless you got bundles
+ */
+export async function getPreloadModulesMeta(specifier, // unversioned specifier
+viewPreloads, bundleConfig, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, pending) {
+    const { exclude = [], external = {}, groups = {} } = bundleConfig;
+    const isExternal = function (rawSpecifier) {
+        const { specifier } = explodeSpecifier(rawSpecifier);
+        return Object.keys(external).includes(specifier);
+    };
+    const isExclude = function (specifier) {
+        return exclude.includes(specifier);
+    };
+    if (isExternal(specifier)) {
+        logger.warn(`"${specifier}" is configured in both bundleConfig.externals and bootstrap.preloadModules. We are treating it as external.`);
+    }
+    else {
+        // eslint-disable-next-line no-await-in-loop
+        const versionedModuleId = await getVersionedModuleId(specifier, moduleRegistry); // TODO replace moduleRegistry with defRegistry
+        const versionedModuleSpecifier = getSpecifier({
+            specifier,
+            version: normalizeVersionToUri(versionedModuleId.version),
+        });
+        const uri = 
+        // eslint-disable-next-line no-await-in-loop
+        await defRegistry.resolveModuleUri(versionedModuleId, runtimeEnvironment, runtimeParams);
+        // fallback to unversioned specifier if needed
+        const normalizedSpecifier = versionedModuleId.version === VERSION_NOT_PROVIDED ? specifier : versionedModuleSpecifier;
+        setPreloadModulesMeta(normalizedSpecifier, uri, groups, viewPreloads);
+        if (exclude.length || Object.keys(groups).length) {
+            // check if we need to also preload any excluded dependencies of this preload module
+            const preloadModuleRecord = await defRegistry.getModuleBundle(versionedModuleId, runtimeEnvironment, runtimeParams);
+            const { imports } = preloadModuleRecord.bundleRecord;
+            if (imports) {
+                if (!pending) {
+                    pending = new Map();
+                }
+                for (let i = 0; i < imports.length; i++) {
+                    const imp = imports[i];
+                    if (!pending.has(imp.specifier) &&
+                        (isExclude(imp.specifier) || isGroupie(imp.specifier, groups))) {
+                        pending.set(imp.specifier, true); // prevent dupe calls
+                        // eslint-disable-next-line no-await-in-loop
+                        await getPreloadModulesMeta(imp.specifier, viewPreloads, bundleConfig, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, pending);
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=preload-utils.js.map

package/build/es/linkers/utils.d.ts

@@ -1,12 +1,6 @@
-import { ClientBootstrapConfig, RuntimeEnvironment, RuntimeParams, ResourceDefinition, RenderedViewMetadata, CustomElementReference, BundleConfig, ModuleBundler, ModuleRegistry } from '@lwrjs/types';
+import { ClientBootstrapConfig, RuntimeEnvironment, RuntimeParams, ResourceDefinition, RenderedViewMetadata, CustomElementReference } from '@lwrjs/types';
 import { View, ViewInfo } from '@lwrjs/types';
 export declare function getViewBootstrapConfigurationResource(viewInfo: ViewInfo, config: ClientBootstrapConfig, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams): ResourceDefinition;
 export declare function getViewHmrConfigurationResource(view: View, viewMetadata: RenderedViewMetadata): ResourceDefinition;
 export declare function flattenCustomElements(arr: CustomElementReference[], isSSR?: boolean): CustomElementReference[];
-/**
- * Recursively gets preloadModules metadata starting with a specifer
- * Note: don't call me unless you got bundles
- */
-export declare function getPreloadModulesMeta(specifier: string, // unversioned specifier
-preloadModulesMeta: Map<string, string>, bundleConfig: BundleConfig, moduleRegistry: ModuleRegistry, defRegistry: ModuleBundler, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, pending?: Map<string, boolean>): Promise<void>;
 //# sourceMappingURL=utils.d.ts.map

package/build/es/linkers/utils.js

@@ -1,4 +1,4 @@
-import { getMappingUriPrefix, getModuleUriPrefix, getClientBootstrapConfigurationUri, hashContent, getVersionedModuleId, normalizeVersionToUri, logger, VERSION_NOT_PROVIDED, explodeSpecifier, getSpecifier, } from '@lwrjs/shared-utils';
+import { getMappingUriPrefix, getModuleUriPrefix, getClientBootstrapConfigurationUri, hashContent, } from '@lwrjs/shared-utils';
 const CONTENT_TYPE = 'application/javascript';
 export function getViewBootstrapConfigurationResource(viewInfo, config, runtimeEnvironment, runtimeParams) {
     const { compat, debug, hmrEnabled, apiVersion, format } = runtimeEnvironment;
@@ -101,54 +101,4 @@ export function flattenCustomElements(arr, isSSR = false) {
     flatten(arr);
     return ret;
 }
-/**
- * Recursively gets preloadModules metadata starting with a specifer
- * Note: don't call me unless you got bundles
- */
-export async function getPreloadModulesMeta(specifier, // unversioned specifier
-preloadModulesMeta, bundleConfig, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, pending) {
-    const { exclude = [], external = {} } = bundleConfig;
-    const isExternal = function (rawSpecifier) {
-        const { specifier } = explodeSpecifier(rawSpecifier);
-        return Object.keys(external).includes(specifier);
-    };
-    const isExclude = function (specifier) {
-        return exclude.includes(specifier);
-    };
-    if (isExternal(specifier)) {
-        logger.warn(`"${specifier}" is configured in both bundleConfig.externals and bootstrap.preloadModules. We are treating it as external.`);
-    }
-    else {
-        // eslint-disable-next-line no-await-in-loop
-        const versionedModuleId = await getVersionedModuleId(specifier, moduleRegistry); // TODO replace moduleRegistry with defRegistry
-        const versionedModuleSpecifier = getSpecifier({
-            specifier,
-            version: normalizeVersionToUri(versionedModuleId.version),
-        });
-        const uri = 
-        // eslint-disable-next-line no-await-in-loop
-        await defRegistry.resolveModuleUri(versionedModuleId, runtimeEnvironment, runtimeParams);
-        // fallback to unversioned specifier if needed
-        const normalizedSpecifier = versionedModuleId.version === VERSION_NOT_PROVIDED ? specifier : versionedModuleSpecifier;
-        preloadModulesMeta.set(normalizedSpecifier, uri);
-        if (exclude.length) {
-            // check if we need to also preload any excluded dependencies of this preload module
-            const preloadModuleRecord = await defRegistry.getModuleBundle(versionedModuleId, runtimeEnvironment, runtimeParams);
-            const { imports } = preloadModuleRecord.bundleRecord;
-            if (imports) {
-                if (!pending) {
-                    pending = new Map();
-                }
-                for (let i = 0; i < imports.length; i++) {
-                    const imp = imports[i];
-                    if (!pending.has(imp.specifier) && isExclude(imp.specifier)) {
-                        pending.set(imp.specifier, true); // prevent dupe calls
-                        // eslint-disable-next-line no-await-in-loop
-                        await getPreloadModulesMeta(imp.specifier, preloadModulesMeta, bundleConfig, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, pending);
-                    }
-                }
-            }
-        }
-    }
-}
 //# sourceMappingURL=utils.js.map

package/build/es/linkers/view_bootstrap.js

@@ -1,11 +1,22 @@
-import { kebabCaseToModuleSpecifier, toImportMetadata, getModuleGraphs, getMappingUriPrefix, GraphDepth, logger, explodeSpecifier, isBundler, } from '@lwrjs/shared-utils';
+import { kebabCaseToModuleSpecifier, toImportMetadata, getModuleGraphs, getMappingUriPrefix, GraphDepth, logger, explodeSpecifier, isBundler, hasHydrateDirective, } from '@lwrjs/shared-utils';
 import { AppResourceEnum, getAppSpecifier } from '@lwrjs/app-service/identity';
 import { generateHtmlTag, getModuleResourceByUri } from '../utils.js';
-import { flattenCustomElements, getViewBootstrapConfigurationResource, getViewHmrConfigurationResource, getPreloadModulesMeta, } from './utils.js';
+import { flattenCustomElements, getViewBootstrapConfigurationResource, getViewHmrConfigurationResource, } from './utils.js';
+import { setPreloadModulesMeta, getPreloadModulesMeta } from './preload-utils.js';
 export async function getHtmlResources(view, viewParams, resourceContext) {
     const { runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler, resourceRegistry, viewMetadata, } = resourceContext;
+    const { lwrVersion, format, hmrEnabled, bundle, debug, minify } = runtimeEnvironment;
+    const { customElements } = viewMetadata;
+    const defRegistry = bundle ? moduleBundler : moduleRegistry;
+    const version = lwrVersion;
+    const isAMD = format === 'amd';
+    const depth = isAMD
+        ? { static: GraphDepth.ALL, dynamic: 1 }
+        : { static: GraphDepth.NONE, dynamic: 1 };
     const { bundleConfig } = resourceContext;
     const { external = {} } = bundleConfig;
+    // Bundling groups is only supported in AMD for now
+    const groups = isAMD ? bundleConfig.groups || {} : {};
     const isExternal = function (rawSpecifier) {
         const { specifier } = explodeSpecifier(rawSpecifier);
         return Object.keys(external).some((e) => specifier === e);
@@ -14,11 +25,6 @@ export async function getHtmlResources(view, viewParams, resourceContext) {
         services: [],
         preloadModules: [],
     }, } = view;
-    const { lwrVersion, format, hmrEnabled, bundle, debug, minify } = runtimeEnvironment;
-    const { customElements } = viewMetadata;
-    const defRegistry = bundle ? moduleBundler : moduleRegistry;
-    const version = lwrVersion;
-    const isAMD = format === 'amd';
     // The Application Bootstrap (ABS) module resource is EITHER
     //      - configured as routes[x].bootstrap.module OR
     //      - defaulted as "@lwrjs/app-service/{appName}/module/{format}"
@@ -49,139 +55,156 @@ export async function getHtmlResources(view, viewParams, resourceContext) {
     const rootComponents = [];
     // Collection of modules specifiers that MUST be loaded in the view
     const requiredAmdModules = [];
-    // Collection of modules that will be preloaded. For AMD, it will be part of
-    // the preloadModules client bootstrap config
-    const preloadModulesMeta = new Map();
+    // Collect preload modules metadata
+    const viewPreloads = {
+        uris: [],
+        specifiers: [],
+        groups: new Map(),
+    };
     // Determine if server side rendering view modules
     const isSSR = view.bootstrap?.ssr;
-    // ------ AMD Required module resources
-    if (isAMD) {
-        // Keep shim format in sync with legacy_view_bootstrap.ts
-        const shimBundle = debug || minify === false ? 'lwr-loader-shim.bundle.js' : 'lwr-loader-shim.bundle.min.js';
-        const def = (await resourceRegistry.getResource({ specifier: shimBundle, version }, runtimeEnvironment, runtimeParams));
-        if (!def) {
-            throw Error('Failed to find definition of resource: ' + shimBundle);
-        }
-        requiredResources.push(def);
-        // Always inline the error shim script after the shim
-        const errorShimDef = (await resourceRegistry.getResource({ specifier: 'lwr-error-shim.js', version }, runtimeEnvironment, runtimeParams));
-        if (!errorShimDef) {
-            throw Error('Failed to find definition of resource: lwr-error-shim.js');
-        }
-        requiredResources.push(errorShimDef);
-    }
-    // ------- Application Bootstrap module
-    // Traversal of the Bootstrap Module Graph is done to get all the URLS for discoverable static dependencies.
-    // Reasoning: This is to avoid unnecessary HTTP 302's during initial application module fetching.
-    const depth = isAMD
-        ? { static: GraphDepth.ALL, dynamic: 1 }
-        : { static: GraphDepth.NONE, dynamic: 1 };
-    const bootstrapModuleGraph = await getModuleGraphs(bootstrapSpecifier, { includeUris: true, includeLinkedDefinitions: true, depth }, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, visitedCache);
-    // ADD bootstrap module uri as a script resource
-    const versionedSpecifier = bootstrapModuleGraph.graphs[0].specifier;
-    const uri = bootstrapModuleGraph.uriMap[versionedSpecifier];
-    moduleResources.push(getModuleResourceByUri(uri, runtimeEnvironment, { isPreload: false, isSSR }));
-    // PRELOAD the bootstrap module static dependencies as preloaded script resources
-    for (const depSpecifier of bootstrapModuleGraph.graphs[0].static) {
-        if (!isExternal(depSpecifier)) {
-            const uri = bootstrapModuleGraph.uriMap[depSpecifier];
-            preloadModulesMeta.set(depSpecifier, uri);
+    // ABS module and custom element references
+    let bootstrapModuleRef, versionedSpecifier = bootstrapSpecifier;
+    let importMetadata = { imports: {} };
+    const customElementsRecords = [];
+    const flattenedElements = flattenCustomElements(customElements, isSSR);
+    const viewContainsHydratedElements = !isSSR || flattenedElements.some(({ props }) => hasHydrateDirective(props));
+    if (viewContainsHydratedElements) {
+        // ------ AMD Required module resources
+        if (isAMD) {
+            // Keep shim format in sync with legacy_view_bootstrap.ts
+            const shimBundle = debug || minify === false ? 'lwr-loader-shim.bundle.js' : 'lwr-loader-shim.bundle.min.js';
+            const def = (await resourceRegistry.getResource({ specifier: shimBundle, version }, runtimeEnvironment, runtimeParams));
+            if (!def) {
+                throw Error('Failed to find definition of resource: ' + shimBundle);
+            }
+            requiredResources.push(def);
+            // Always inline the error shim script after the shim
+            const errorShimDef = (await resourceRegistry.getResource({ specifier: 'lwr-error-shim.js', version }, runtimeEnvironment, runtimeParams));
+            if (!errorShimDef) {
+                throw Error('Failed to find definition of resource: lwr-error-shim.js');
+            }
+            requiredResources.push(errorShimDef);
         }
-    }
-    // PRELOAD configured preloadModules as preloaded script resources
-    if (isBundler(defRegistry)) {
-        for (const specifier of preloadModules) {
-            // eslint-disable-next-line no-await-in-loop
-            await getPreloadModulesMeta(specifier, preloadModulesMeta, bundleConfig, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams);
+        // ------- Application Bootstrap module
+        // Traversal of the Bootstrap Module Graph is done to get all the URLS for discoverable static dependencies.
+        // Reasoning: This is to avoid unnecessary HTTP 302's during initial application module fetching.
+        const bootstrapModuleGraph = await getModuleGraphs(bootstrapSpecifier, { includeUris: true, includeLinkedDefinitions: true, depth }, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, visitedCache);
+        bootstrapModuleRef = {
+            specifier: bootstrapModuleGraph.graphs[0].specifier,
+            flatGraph: bootstrapModuleGraph,
+            resources: configResources,
+        };
+        // ADD bootstrap module uri as a script resource
+        versionedSpecifier = bootstrapModuleGraph.graphs[0].specifier;
+        const uri = bootstrapModuleGraph.uriMap[versionedSpecifier];
+        moduleResources.push(getModuleResourceByUri(uri, runtimeEnvironment, { isPreload: false, isSSR }));
+        // PRELOAD the bootstrap module static dependencies as preloaded script resources
+        for (const depSpecifier of bootstrapModuleGraph.graphs[0].static) {
+            if (!isExternal(depSpecifier)) {
+                const uri = bootstrapModuleGraph.uriMap[depSpecifier];
+                setPreloadModulesMeta(depSpecifier, uri, groups, viewPreloads);
+            }
         }
-    }
-    if (isAMD) {
-        // ADD bootstrap module as required
-        requiredAmdModules.push(versionedSpecifier);
-        // ADD bootstrap module uri addressability
-        imports[versionedSpecifier] = uri;
-        // PRELOAD bootstrap module static deps as link resource
-        for (const staticDep of bootstrapModuleGraph.graphs[0].static) {
-            const uri = bootstrapModuleGraph.uriMap[staticDep];
-            // ADD static module dep uri addressability
-            imports[staticDep] = uri;
-            // ADD bootstrap module static deps to requiredAmdModules if services, otherwise preloadModules
-            if (services && services.length) {
-                requiredAmdModules.push(staticDep);
+        // PRELOAD configured preloadModules as preloaded script resources
+        if (isBundler(defRegistry)) {
+            for (const specifier of preloadModules) {
+                // eslint-disable-next-line no-await-in-loop
+                await getPreloadModulesMeta(specifier, viewPreloads, bundleConfig, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams);
             }
         }
-        // Add import mappings for known dynamic imports
-        for (const dynamicDep of bootstrapModuleGraph.graphs[0].dynamicRefs) {
-            const uri = bootstrapModuleGraph.uriMap[dynamicDep];
-            if (uri) {
-                imports[dynamicDep] = uri;
+        if (isAMD) {
+            // ADD bootstrap module as required
+            requiredAmdModules.push(versionedSpecifier);
+            // ADD bootstrap module uri addressability
+            imports[versionedSpecifier] = uri;
+            // PRELOAD bootstrap module static deps as link resource
+            for (const staticDep of bootstrapModuleGraph.graphs[0].static) {
+                const uri = bootstrapModuleGraph.uriMap[staticDep];
+                // ADD static module dep uri addressability
+                imports[staticDep] = uri;
+                // ADD bootstrap module static deps to requiredAmdModules if services, otherwise preloadModules
+                if (services && services.length) {
+                    requiredAmdModules.push(staticDep);
+                }
             }
-            else {
-                logger.warn('Skipping unknown dynamic import ' + dynamicDep);
+            // Add import mappings for known dynamic imports
+            for (const dynamicDep of bootstrapModuleGraph.graphs[0].dynamicRefs) {
+                const uri = bootstrapModuleGraph.uriMap[dynamicDep];
+                if (uri) {
+                    imports[dynamicDep] = uri;
+                }
+                else {
+                    logger.warn('Skipping unknown dynamic import ' + dynamicDep);
+                }
             }
         }
+        importMetadata = await toImportMetadata(bootstrapModuleGraph, { imports: {}, index: {} }, moduleRegistry, runtimeEnvironment, runtimeParams);
     }
-    let importMetadata = await toImportMetadata(bootstrapModuleGraph, { imports: {}, index: {} }, moduleRegistry, runtimeEnvironment, runtimeParams);
     // ------- View related custom element moduleResources
-    const customElementsRecords = [];
-    const flattenedElements = flattenCustomElements(customElements, isSSR);
-    for (const { tagName: element } of flattenedElements) {
+    for (const { tagName: element, props } of flattenedElements) {
         // eslint-disable-next-line no-await-in-loop
         const graph = await getModuleGraphs(kebabCaseToModuleSpecifier(element), { includeUris: true, includeLinkedDefinitions: true, depth }, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams ? runtimeParams : {}, visitedCache);
         // add to the viewRecord
         customElementsRecords.push({ elementName: element, flatGraph: graph });
-        // PRELOAD the custom element module as a link resource
-        const specifier = graph.graphs[0].specifier;
-        const uri = graph.uriMap[specifier];
-        preloadModulesMeta.set(specifier, uri);
-        // PRELOAD custom element static deps as link resources when bundling is ON
-        if (bundle) {
-            for (const depSpecifier of graph.graphs[0].static) {
-                if (!isExternal(depSpecifier)) {
-                    const uri = graph.uriMap[depSpecifier];
-                    preloadModulesMeta.set(depSpecifier, uri);
+        // Only process custom elements that are to be hydrated
+        if (!isSSR || hasHydrateDirective(props)) {
+            // PRELOAD the custom element module as a link resource
+            const specifier = graph.graphs[0].specifier;
+            const uri = graph.uriMap[specifier];
+            setPreloadModulesMeta(specifier, uri, groups, viewPreloads);
+            // PRELOAD custom element static deps as link resources when bundling is ON
+            if (bundle) {
+                for (const depSpecifier of graph.graphs[0].static) {
+                    if (!isExternal(depSpecifier)) {
+                        const uri = graph.uriMap[depSpecifier];
+                        setPreloadModulesMeta(depSpecifier, uri, groups, viewPreloads);
+                    }
                 }
             }
-        }
-        // ADD register custom elements as a uri addressable rootComponents
-        rootComponents.push(specifier);
-        imports[specifier] = uri;
-        if (isAMD) {
-            for (const staticDep of graph.graphs[0].static) {
-                const uri = graph.uriMap[staticDep];
-                // AMD ADD static module dep uri addressability
-                imports[staticDep] = uri;
-            }
-            // AMD ADD dynamic imports module dep uri addressability
-            for (const dynamicDep of graph.graphs[0].dynamicRefs) {
-                const uri = graph.uriMap[dynamicDep];
-                imports[dynamicDep] = uri;
+            // ADD register custom elements as a uri addressable rootComponents
+            rootComponents.push(specifier);
+            imports[specifier] = uri;
+            if (isAMD) {
+                for (const staticDep of graph.graphs[0].static) {
+                    const uri = graph.uriMap[staticDep];
+                    // AMD ADD static module dep uri addressability
+                    imports[staticDep] = uri;
+                }
+                // AMD ADD dynamic imports module dep uri addressability
+                for (const dynamicDep of graph.graphs[0].dynamicRefs) {
+                    const uri = graph.uriMap[dynamicDep];
+                    imports[dynamicDep] = uri;
+                }
             }
+            // eslint-disable-next-line no-await-in-loop
+            importMetadata = await toImportMetadata(graph, importMetadata, moduleRegistry, runtimeEnvironment, runtimeParams);
         }
-        // eslint-disable-next-line no-await-in-loop
-        importMetadata = await toImportMetadata(graph, importMetadata, moduleRegistry, runtimeEnvironment, runtimeParams);
     }
-    // ADD configuration of the bootstrapModule
-    configResources.unshift(await getViewBootstrapConfigurationResource({
-        id: view.id,
-        url: viewParams?.page?.url,
-        configAsSrc: view.bootstrap?.configAsSrc || false,
-    }, {
-        appId: appIdentity.appName,
-        bootstrapModule: versionedSpecifier,
-        autoBoot: view.bootstrap?.autoBoot === false ? false : true,
-        imports: importMetadata?.imports,
-        index: importMetadata?.index,
-        rootComponents,
-        ...(isAMD && { requiredModules: requiredAmdModules }),
-        // in AMD we need to tell the loader what modules we are preloading
-        ...(isAMD && { preloadModules: Array.from(preloadModulesMeta.keys()) }),
-    }, runtimeEnvironment, runtimeParams));
+    if (viewContainsHydratedElements) {
+        // ADD configuration of the bootstrapModule
+        configResources.unshift(getViewBootstrapConfigurationResource({
+            id: view.id,
+            url: viewParams?.page?.url,
+            configAsSrc: view.bootstrap?.configAsSrc || false,
+        }, {
+            appId: appIdentity.appName,
+            bootstrapModule: versionedSpecifier,
+            autoBoot: view.bootstrap?.autoBoot === false ? false : true,
+            imports: importMetadata?.imports,
+            index: importMetadata?.index,
+            rootComponents,
+            ...(isAMD && { requiredModules: requiredAmdModules }),
+            // in AMD we need to tell the loader what modules we are preloading
+            ...(isAMD && { preloadModules: viewPreloads.specifiers }),
+        }, runtimeEnvironment, runtimeParams));
+    }
     if (!isAMD && hmrEnabled) {
-        configResources.unshift(await getViewHmrConfigurationResource(view, viewMetadata));
+        configResources.unshift(getViewHmrConfigurationResource(view, viewMetadata));
     }
     // PRELOAD script resources for preload module URIs after the bootstrap module
-    for (const [, preloadUri] of preloadModulesMeta) {
+    const dedupedUris = [...new Set(viewPreloads.uris)];
+    for (const preloadUri of dedupedUris) {
         moduleResources.push(getModuleResourceByUri(preloadUri, runtimeEnvironment, { isPreload: true, isSSR }));
     }
     // generate html partial
@@ -199,11 +222,7 @@ export async function getHtmlResources(view, viewParams, resourceContext) {
             customElements: customElementsRecords,
             endpoints,
             importMetadata,
-            bootstrapModule: {
-                specifier: bootstrapModuleGraph.graphs[0].specifier,
-                flatGraph: bootstrapModuleGraph,
-                resources: configResources,
-            },
+            bootstrapModule: bootstrapModuleRef,
         },
     };
 }

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.10.0-alpha.13",
+    "version": "0.10.0-alpha.14",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -30,15 +30,15 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/app-service": "0.10.0-alpha.13",
-        "@lwrjs/diagnostics": "0.10.0-alpha.13",
-        "@lwrjs/shared-utils": "0.10.0-alpha.13"
+        "@lwrjs/app-service": "0.10.0-alpha.14",
+        "@lwrjs/diagnostics": "0.10.0-alpha.14",
+        "@lwrjs/shared-utils": "0.10.0-alpha.14"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.10.0-alpha.13"
+        "@lwrjs/types": "0.10.0-alpha.14"
     },
     "engines": {
         "node": ">=16.0.0 <20"
     },
-    "gitHead": "f6d142d5a027554cb1685389e0b173734149683d"
+    "gitHead": "f80dc1c18719b77c183f339027313be11d69f9dc"
 }