@ohos-ports/lwrjs-static 0.24.0-beta.1

package/build/es/providers/static-asset-provider.js

@@ -0,0 +1,90 @@
+import { logger } from '@lwrjs/diagnostics';
+import { hashContent, joinUrlPath, mimeLookup, normalizeResourcePath } from '@lwrjs/shared-utils';
+import path from 'path';
+import fs from 'fs-extra';
+export default class StaticAssetProvider {
+    constructor(_config, context) {
+        this.name = 'static-asset-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        const { assets, rootDir, layoutsDir, contentDir } = context.config;
+        this.siteAssets = context.siteMetadata.getSiteAssets();
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.basePath = context.runtimeEnvironment.basePath;
+        this.assetsOnLambda = !!context.runtimeEnvironment.featureFlags?.ASSETS_ON_LAMBDA;
+        // Adjust the assets directories to be rooted in ssg folder.
+        const ssgAssets = Array.from(assets, (asset) => {
+            if (asset.dir) {
+                // Return the URI as the dir where it will be relative to the ssg root
+                return {
+                    ...asset,
+                    dir: asset.urlPath,
+                };
+            }
+            return asset;
+        });
+        this.resourcePaths = { assets: ssgAssets, rootDir, layoutsDir, contentDir };
+    }
+    async getAsset(assetIdentifier) {
+        // Set all the asset path to resolve to the ssg root
+        const fileAssetPath = this.normalizeSpecifier(assetIdentifier, this.resourcePaths);
+        const metadata = this.siteAssets.assets[fileAssetPath];
+        if (!metadata) {
+            // Ignore root asset misses (may be views)
+            if (path.dirname(fileAssetPath) !== (this.basePath ? this.basePath : '/')) {
+                logger.warn({
+                    label: `${this.name}`,
+                    message: `Did not find requested specifier ${fileAssetPath}`,
+                });
+            }
+            return undefined;
+        }
+        // FS path including ssg root
+        const siteAssetPath = joinUrlPath(this.siteRootDir, metadata.path);
+        // Figure out mime type
+        const mime = metadata.mimeType || mimeLookup(siteAssetPath);
+        // Normalize extension
+        const ext = path.extname(`x.${siteAssetPath}`).toLowerCase().substring(1);
+        // Unless assets on lambda feature flag is set indicate the asset source is external
+        const type = this.assetsOnLambda ? 'asset' : 'external';
+        const content = function (encoding) {
+            return fs.readFileSync(siteAssetPath, encoding);
+        };
+        // Create URI
+        const uri = this.assetsOnLambda ? fileAssetPath : joinUrlPath(this.siteRootDir, fileAssetPath);
+        logger.debug({ label: `${this.name}`, message: `uri ${assetIdentifier.specifier} -> ${uri}` });
+        return {
+            entry: siteAssetPath,
+            ext,
+            mime,
+            ownHash: hashContent(metadata.path),
+            content,
+            uri,
+            // Type: external triggers a 302 when requested form the asset middleware.
+            type,
+            noTransform: true,
+        };
+    }
+    /**
+     * Replaces and aliased resource paths (i.e. $assetDir with a qualified specifier)
+     */
+    normalizeSpecifier(assetId, resourcePaths) {
+        const { specifier } = assetId;
+        // Remove query params from specifiers (i.e. /assets/styles/styles.css?e368d71b59)
+        let normalizedSpecifier = specifier;
+        if (normalizedSpecifier.includes('?')) {
+            logger.debug({
+                label: `${this.name}`,
+                message: `Removed query param from asset specifier: ${specifier}`,
+            });
+            normalizedSpecifier = normalizedSpecifier.split('?')[0];
+        }
+        if (normalizedSpecifier[0] === '$') {
+            // This is a fs path containing an asset alias
+            return normalizeResourcePath(normalizedSpecifier, resourcePaths);
+        }
+        return normalizedSpecifier;
+    }
+}
+//# sourceMappingURL=static-asset-provider.js.map

package/build/es/providers/static-bundle-provider.d.ts

@@ -0,0 +1,59 @@
+import type { AbstractModuleId, BundleDefinition, BundleProvider, ProviderContext, RuntimeEnvironment, RuntimeParams, SiteBundle, SiteMetadata } from '@lwrjs/types';
+import { LRUCache } from 'lru-cache';
+export default class StaticBundleProvider implements BundleProvider {
+    name: string;
+    codeCache: LRUCache<string, string, unknown> | undefined;
+    siteRootDir: string;
+    bundleConfig: import("@lwrjs/types").BundleConfig;
+    i18n: import("@lwrjs/types").I18NConfig;
+    siteMetadata: SiteMetadata;
+    bundleCacheSize: number;
+    constructor(config: {
+        bundleCacheSize?: number;
+    }, context: ProviderContext);
+    bundle<BundleIdentifier extends AbstractModuleId, RE extends RuntimeEnvironment>(moduleId: BundleIdentifier, runtimeEnvironment: RE, runtimeParams: RuntimeParams): Promise<BundleDefinition | undefined>;
+    private createBundleDefinition;
+    getBundleMetadata({ moduleId, localeId, debug, ssr, }: {
+        moduleId: Partial<AbstractModuleId>;
+        localeId: string;
+        debug: boolean;
+        ssr: boolean;
+    }): SiteBundle | undefined;
+    /**
+     * Takes a key from the site bundle metadata and creates an appropriate runtime BaseModuleReference to use in the LWR runtime.
+     */
+    private getModuleReference;
+    getCodePromiser(bundleSourcePath: string, { specifier, version, locale, ssr, debug, }: {
+        specifier: string;
+        version?: string;
+        locale: string;
+        ssr: boolean;
+        debug: boolean;
+    }): () => Promise<string>;
+    /**
+     * Logs an error when a bundle fails to load and provides debugging metadata.
+     *
+     * This function logs details about the failed bundle load attempt, including the module ID,
+     * locale, debug mode, and SSR status. It also attempts to retrieve additional metadata
+     * about the site bundles and debug bundles associated with the module.
+     *
+     * @param {Partial<AbstractModuleId>} moduleId - The module identifier, which may include a namespace and name.
+     * @param {string} localeId - The locale associated with the bundle.
+     * @param {boolean} debug - Indicates whether debug mode is enabled.
+     * @param {boolean} ssr - Indicates whether the bundle is for server-side rendering (SSR).
+     */
+    logBundleError(moduleId: Partial<AbstractModuleId>, localeId: string, debug: boolean, ssr: boolean): void;
+    /**
+     * Get the local source code path for the a static bundle
+     * If we are running in a lambda and the mode is debug we will return the prod source code instead of the debug source code
+     *
+     * @param bundlePath The default path for the bundle for prod read from .metadata/bundle-metadata.json, for debug .metadata/bundle-metadata-debug.json
+     * @param debug Is the request in debug mode?
+     * @param specifier Root specifier for the requested bundle
+     * @param version Root specifier version
+     * @param localeId Locale id (e.g. en-US) for the current request
+     * @param ssr True if this is a server bundle
+     */
+    getCodePath(bundlePath: string, debug: boolean, specifier: string, version: string | undefined, localeId: string, ssr: boolean): string;
+}
+//# sourceMappingURL=static-bundle-provider.d.ts.map

package/build/es/providers/static-bundle-provider.js

@@ -0,0 +1,257 @@
+import { logger } from '@lwrjs/diagnostics';
+import { VERSION_SIGIL, explodeSpecifier, getSpecifier, isExternalSpecifier, isLambdaEnv, joinUrlPath, normalizeFromFileURL, } from '@lwrjs/shared-utils';
+import path from 'path';
+import fs from 'fs-extra';
+import { LRUCache } from 'lru-cache';
+import { getSiteBundleId, parseSiteId, resolveStaticBundleVersion } from '../site-metadata.js';
+import { cacheCountStore } from '@lwrjs/instrumentation';
+import { getTracer, BundleSpan } from '@lwrjs/instrumentation';
+const BUNDLE_SOURCE_NOT_FOUND = 'Bundle Source Path Not Found';
+export default class StaticBundleProvider {
+    constructor(config, context) {
+        this.name = 'static-bundle-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        this.siteMetadata = context.siteMetadata;
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.bundleConfig = context.config.bundleConfig;
+        this.i18n = context.config.i18n;
+        this.bundleCacheSize =
+            config.bundleCacheSize ?? parseInt(process.env.BUNDLE_CODE_CACHE_SIZE ?? '500', 10);
+        if (this.bundleCacheSize > 0) {
+            this.codeCache = new LRUCache({
+                max: this.bundleCacheSize,
+                dispose: (_value, key) => {
+                    if (isLambdaEnv()) {
+                        logger.warn(`Bundle Code evicted from cache ${key}`);
+                    }
+                    else {
+                        logger.verbose(`Bundle Code evicted from cache ${key}`);
+                    }
+                },
+            });
+        }
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams) {
+        const { specifier, version } = moduleId;
+        const { debug, i18n: { defaultLocale }, } = runtimeEnvironment;
+        const localeId = (runtimeParams?.locale || defaultLocale);
+        const ssr = runtimeParams?.ssr;
+        let metadata = this.getBundleMetadata({ moduleId, localeId, debug, ssr });
+        if (!metadata && debug) {
+            // Fallback to use prod bundles if the debug variant does not exist
+            // eg: debug bundles are not shipped to the Lambda
+            // eg: locally, an MRT bundle may or may not have debug metadata, depending on how it's generated
+            metadata = this.getBundleMetadata({ moduleId, localeId, debug: false, ssr });
+        }
+        if (!metadata && isExternalSpecifier(moduleId.specifier, this.bundleConfig)) {
+            const { specifier: unversionedSepcifier } = explodeSpecifier(moduleId.specifier);
+            metadata = {
+                path: this.bundleConfig?.external?.[unversionedSepcifier],
+                imports: [],
+                dynamicImports: [],
+                version: moduleId.version,
+            };
+            return this.createBundleDefinition(moduleId, metadata, localeId, debug, ssr, async () => '', normalizeFromFileURL(metadata.path, this.siteRootDir) ?? metadata.path);
+        }
+        if (!metadata) {
+            this.logBundleError(moduleId, localeId, debug, ssr);
+            return undefined;
+        }
+        // Default bundle source path
+        const bundlePath = joinUrlPath(this.siteRootDir, metadata.path);
+        // Get the associated bundle source code
+        const resolvedBundlePath = this.getCodePath(bundlePath, debug, specifier, version, localeId, ssr);
+        const codePromiser = this.getCodePromiser(resolvedBundlePath, {
+            specifier,
+            version,
+            locale: localeId,
+            ssr,
+            debug,
+        });
+        return this.createBundleDefinition(moduleId, metadata, localeId, debug, ssr, codePromiser, bundlePath);
+    }
+    async createBundleDefinition(moduleId, metadata, localeId, debug, ssr, codePromiser, bundlePath) {
+        const { specifier, name, namespace, version } = moduleId;
+        const imports = metadata.imports.map((importSpecifier) => this.getModuleReference(importSpecifier, localeId, debug, false));
+        const dynamicImports = metadata.dynamicImports?.map((importSpecifier) => this.getModuleReference(importSpecifier, localeId, debug, false));
+        const id = getSpecifier(moduleId);
+        const exploded = explodeSpecifier(id);
+        // Seem unlikely name was not in the moduleId but just incase set it form the exploded id
+        const resolvedName = name ?? exploded.name;
+        const resolvedNamespace = namespace ?? exploded.namespace;
+        const resolvedVersion = resolveStaticBundleVersion(metadata.version, version);
+        const includedModules = metadata.includedModules?.map((includedId) => {
+            const includedModule = this.getModuleReference(includedId, localeId, debug, ssr);
+            return getSpecifier(includedModule);
+        }) || [];
+        return {
+            getCode: codePromiser,
+            id: getSpecifier({
+                specifier: specifier,
+                version: resolvedVersion,
+                name: resolvedName,
+                namespace: resolvedNamespace,
+            }),
+            name: resolvedName,
+            namespace: resolvedNamespace,
+            version: resolvedVersion,
+            specifier: specifier,
+            config: this.bundleConfig,
+            integrity: metadata.integrity,
+            bundleRecord: {
+                // TODO we need to solve include modules for fingerprints support
+                includedModules,
+                imports,
+                dynamicImports,
+            },
+            src: bundlePath,
+        };
+    }
+    getBundleMetadata({ moduleId, localeId, debug, ssr, }) {
+        const siteBundleId = getSiteBundleId(moduleId, localeId, ssr, this.i18n);
+        return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
+    }
+    /**
+     * Takes a key from the site bundle metadata and creates an appropriate runtime BaseModuleReference to use in the LWR runtime.
+     */
+    getModuleReference(siteBundleIdStr, localeId, debug, ssr) {
+        const siteBundleId = parseSiteId(siteBundleIdStr);
+        const includedModule = explodeSpecifier(siteBundleId.specifier);
+        if (!siteBundleId.variants[VERSION_SIGIL]) {
+            const importBundleMetadata = this.siteMetadata
+                .getSiteBundlesDecisionTree()
+                .find(siteBundleIdStr, debug, ssr, localeId);
+            includedModule.version = resolveStaticBundleVersion(importBundleMetadata?.version);
+        }
+        else {
+            includedModule.version = siteBundleId.variants[VERSION_SIGIL];
+        }
+        return includedModule;
+    }
+    getCodePromiser(bundleSourcePath, { specifier, version, locale, ssr, debug, }) {
+        const cache = this.codeCache;
+        return async () => {
+            let code = cache?.get(bundleSourcePath);
+            if (!code) {
+                try {
+                    // Debug metadata was not found
+                    if (bundleSourcePath === BUNDLE_SOURCE_NOT_FOUND) {
+                        throw new Error(BUNDLE_SOURCE_NOT_FOUND);
+                    }
+                    // Increment the cache count store
+                    cacheCountStore.incrementCacheKey('missedReads');
+                    await getTracer().trace({
+                        name: BundleSpan.ReadBundle,
+                        attributes: {
+                            specifier,
+                            version: version ?? '',
+                            locale,
+                            ssr: ssr ? 'TRUE' : 'FALSE',
+                            debug: debug ? 'TRUE' : 'FALSE',
+                            bundleSourcePath,
+                        },
+                    }, async () => {
+                        code = await fs.readFile(path.join(bundleSourcePath), 'utf-8');
+                        if (cache) {
+                            cache.set(bundleSourcePath, code);
+                        }
+                    });
+                }
+                catch (err) {
+                    // Ran it an un-expected error reading the bundle source code
+                    logger.warn({
+                        label: 'static-bundle-provider',
+                        message: `Unexpected code reference: ${specifier} ${bundleSourcePath}`,
+                    }, err);
+                    // Returning source code that throws and error is someone tries to evaluate it
+                    code = `throw new Error('Unexpected code reference: ${specifier} ${bundleSourcePath}');`;
+                    if (cache) {
+                        cache.set(bundleSourcePath, code);
+                    }
+                }
+            }
+            return code;
+        };
+    }
+    /**
+     * Logs an error when a bundle fails to load and provides debugging metadata.
+     *
+     * This function logs details about the failed bundle load attempt, including the module ID,
+     * locale, debug mode, and SSR status. It also attempts to retrieve additional metadata
+     * about the site bundles and debug bundles associated with the module.
+     *
+     * @param {Partial<AbstractModuleId>} moduleId - The module identifier, which may include a namespace and name.
+     * @param {string} localeId - The locale associated with the bundle.
+     * @param {boolean} debug - Indicates whether debug mode is enabled.
+     * @param {boolean} ssr - Indicates whether the bundle is for server-side rendering (SSR).
+     */
+    logBundleError(moduleId, localeId, debug, ssr) {
+        const moduleSpecifier = moduleId.namespace
+            ? `${moduleId.namespace}/${moduleId.name}`
+            : moduleId.name;
+        const siteBundleId = getSiteBundleId(moduleId, localeId, ssr, this.i18n);
+        // Retrieve site bundles and debug bundles
+        const siteBundles = this.siteMetadata.getSiteBundles()?.bundles || {};
+        const siteDebugBundles = this.siteMetadata.getDebugSiteBundles()?.bundles || {};
+        // Extract keys and filter bundles by module specifier
+        const runtimeBundles = Object.keys(siteBundles).filter((key) => key.startsWith(moduleSpecifier));
+        const debugBundles = Object.keys(siteDebugBundles).filter((key) => key.startsWith(moduleSpecifier));
+        logger.error({
+            message: JSON.stringify({
+                message: 'Failed to find static bundle',
+                moduleId,
+                localeId,
+                debug,
+                ssr,
+                moduleSpecifier,
+                siteBundleId,
+                debugBundles,
+                runtimeBundles,
+                totalBundlesCount: Object.keys(siteBundles).length,
+                totalDebugBundlesCount: Object.keys(siteDebugBundles).length,
+            }),
+            label: 'static-bundle-provider',
+        });
+    }
+    /**
+     * Get the local source code path for the a static bundle
+     * If we are running in a lambda and the mode is debug we will return the prod source code instead of the debug source code
+     *
+     * @param bundlePath The default path for the bundle for prod read from .metadata/bundle-metadata.json, for debug .metadata/bundle-metadata-debug.json
+     * @param debug Is the request in debug mode?
+     * @param specifier Root specifier for the requested bundle
+     * @param version Root specifier version
+     * @param localeId Locale id (e.g. en-US) for the current request
+     * @param ssr True if this is a server bundle
+     */
+    getCodePath(bundlePath, debug, specifier, version, localeId, ssr) {
+        // Flag is used to indicate that we are running on a lambda
+        const isLambda = isLambdaEnv() || process.env.FORCE_DEBUG_FALLBACK === 'true'; // Env variable for testing purposes only
+        // Default source code path determined from metadata based on debug mode
+        let bundleSourcePath = bundlePath;
+        // This is the special case where the request is in debug mode and we are on the lambda
+        // So we will look up the prod source code instead of the debug source code
+        if (debug && isLambda) {
+            const metadata = this.getBundleMetadata({
+                moduleId: { specifier, version },
+                localeId,
+                debug: false,
+                ssr,
+            });
+            if (!metadata) {
+                // We did not find the bundle prod bundle even though we did find it in the debug metadata before
+                logger.error({
+                    label: 'static-bundle-provider',
+                    message: `debug-to-prod fallback missing metadata for specifier: ${specifier}`,
+                });
+                return BUNDLE_SOURCE_NOT_FOUND;
+            }
+            // Overwrite the default source code path the prod source code path
+            bundleSourcePath = joinUrlPath(this.siteRootDir, metadata.path);
+        }
+        return bundleSourcePath;
+    }
+}
+//# sourceMappingURL=static-bundle-provider.js.map

package/build/es/providers/static-module-provider.d.ts

@@ -0,0 +1,15 @@
+import type { AbstractModuleId, I18NConfig, ModuleCompiled, ModuleEntry, ModuleProvider, ProviderContext, RuntimeParams, SiteMetadata } from '@lwrjs/types';
+export default class StaticModuleProvider implements ModuleProvider {
+    name: string;
+    siteRootDir: string;
+    externals: string[];
+    fingerprintIndex: Record<string, ModuleEntry>;
+    i18n: I18NConfig;
+    siteMetadata: SiteMetadata;
+    constructor(_config: {}, context: ProviderContext);
+    getModule<T extends AbstractModuleId>(moduleId: T, runtimeParams: RuntimeParams): Promise<ModuleCompiled | undefined>;
+    getModuleEntry<T extends AbstractModuleId>(moduleId: T, runtimeParams: RuntimeParams): Promise<ModuleEntry | undefined>;
+    private getEntryFromFingerprintIndex;
+    private getBundleMetadata;
+}
+//# sourceMappingURL=static-module-provider.d.ts.map

package/build/es/providers/static-module-provider.js

@@ -0,0 +1,118 @@
+import { logger } from '@lwrjs/diagnostics';
+import { VERSION_SIGIL, explodeSpecifier, getSpecifier, isLambdaEnv, joinUrlPath } from '@lwrjs/shared-utils';
+import { getSiteBundleId, parseSiteId, resolveStaticBundleVersion } from '../site-metadata.js';
+export default class StaticModuleProvider {
+    constructor(_config, context) {
+        this.name = 'static-module-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        this.externals = Object.keys(context.config.bundleConfig.external || {});
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.i18n = context.config.i18n;
+        this.siteMetadata = context.siteMetadata;
+        // If we are using fingerprints collect all the specifiers in the bundles and add them to an index for creating the mapping identities
+        this.fingerprintIndex = buildFingerprintsIndex(context);
+    }
+    async getModule(moduleId, runtimeParams) {
+        const localeId = (runtimeParams?.locale || this.i18n.defaultLocale);
+        const ssr = runtimeParams?.ssr;
+        const metadata = this.getBundleMetadata({ moduleId, localeId, debug: false, ssr });
+        if (metadata && isLambdaEnv()) {
+            logger.warn({
+                label: `${this.name}`,
+                message: `We should not be asking for module source we have in our site metadata: ${moduleId.specifier}`,
+            });
+            // proceed to next provider
+            return undefined;
+        }
+        // proceed to next provider
+        return undefined;
+    }
+    async getModuleEntry(moduleId, runtimeParams) {
+        // TODO shouldn't we be passing the runtime environment here to test?
+        const { specifier, version } = moduleId;
+        const localeId = (runtimeParams?.locale || this.i18n.defaultLocale);
+        const ssr = runtimeParams?.ssr;
+        const metadata = this.getBundleMetadata({ moduleId, localeId, ssr, debug: false });
+        if (metadata) {
+            logger.debug({
+                label: `${this.name}`,
+                message: `Module Entry request for static bundle ${specifier}`,
+            });
+            // Have to make the bundle code available for SSR
+            const bundlePath = joinUrlPath(this.siteRootDir, metadata.path);
+            const resolvedVersion = resolveStaticBundleVersion(metadata.version, version);
+            return {
+                id: getSpecifier({ ...moduleId, version: resolvedVersion }),
+                version: resolvedVersion,
+                specifier: specifier,
+                entry: 'entry-not-provided',
+                src: bundlePath,
+            };
+        }
+        else if (this.externals.includes(specifier)) {
+            // Externals are not SSG'ed so hard coding definition
+            const resolvedVersion = resolveStaticBundleVersion(undefined, version);
+            return {
+                id: getSpecifier({ ...moduleId, version: resolvedVersion }),
+                version: resolvedVersion,
+                specifier: specifier,
+                entry: 'entry-not-provided',
+            };
+        }
+        // checks the fingerprint index or proceeds to next provider
+        return this.getEntryFromFingerprintIndex(moduleId);
+    }
+    getEntryFromFingerprintIndex(moduleId) {
+        const versionedSpecifier = getSpecifier(moduleId);
+        return this.fingerprintIndex[versionedSpecifier] || this.fingerprintIndex[moduleId.specifier];
+    }
+    getBundleMetadata({ moduleId, localeId, debug, ssr, }) {
+        const siteBundleId = getSiteBundleId(moduleId, localeId, ssr, this.i18n);
+        return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
+    }
+}
+/**
+ * Map each of the includedModules for a bundle to the bundle src
+ * This enables lookup of modules which are not top-level in the bundle metadata
+ */
+function buildFingerprintsIndex(context) {
+    const fingerprintIndex = {};
+    if (!context.runtimeEnvironment.featureFlags.LEGACY_LOADER) {
+        const bundles = context.siteMetadata?.getSiteBundles().bundles || {};
+        for (const bundle of Object.values(bundles)) {
+            const bundlePath = joinUrlPath(String(context.siteMetadata?.getSiteRootDir()), bundle.path);
+            const includedModules = bundle.includedModules || [];
+            for (const includedModule of includedModules) {
+                const versionedSpecifier = convertSiteIdToVersionedSpecifier(includedModule);
+                const moduleId = explodeSpecifier(versionedSpecifier);
+                if (!fingerprintIndex[versionedSpecifier]) {
+                    fingerprintIndex[versionedSpecifier] = {
+                        id: versionedSpecifier,
+                        version: resolveStaticBundleVersion(moduleId.version),
+                        specifier: moduleId.specifier,
+                        entry: 'entry-not-provided',
+                        src: bundlePath,
+                    };
+                }
+                // Add an un-versioned match for the first hit
+                if (!fingerprintIndex[moduleId.specifier]) {
+                    fingerprintIndex[moduleId.specifier] = {
+                        id: moduleId.specifier,
+                        version: resolveStaticBundleVersion(moduleId.version),
+                        specifier: moduleId.specifier,
+                        entry: 'entry-not-provided',
+                        src: bundlePath,
+                    };
+                }
+            }
+        }
+    }
+    return fingerprintIndex;
+}
+function convertSiteIdToVersionedSpecifier(siteId) {
+    const parsedSiteId = parseSiteId(siteId);
+    return getSpecifier({ specifier: parsedSiteId.specifier, version: parsedSiteId.variants[VERSION_SIGIL] });
+}
+//# sourceMappingURL=static-module-provider.js.map

package/build/es/providers/static-resource-provider.d.ts

@@ -0,0 +1,10 @@
+import type { BootstrapRuntimeEnvironment, ProviderContext, ResourceDefinition, ResourceIdentifier, ResourceProvider, RuntimeParams } from '@lwrjs/types';
+export default class StaticResourceProvider implements ResourceProvider {
+    name: string;
+    siteRootDir: string;
+    siteMetadata: import("@lwrjs/types").SiteMetadata;
+    resourceRegistry: import("@lwrjs/types").PublicResourceRegistry;
+    constructor(_config: {}, context: ProviderContext);
+    getResource<Identifier extends ResourceIdentifier, RuntimeEnvironment extends BootstrapRuntimeEnvironment>(resourceIdentity: Identifier, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams): Promise<ResourceDefinition | undefined>;
+}
+//# sourceMappingURL=static-resource-provider.d.ts.map

package/build/es/providers/static-resource-provider.js

@@ -0,0 +1,53 @@
+import { logger } from '@lwrjs/diagnostics';
+import { joinUrlPath, mimeLookup } from '@lwrjs/shared-utils';
+import path from 'path';
+import fs from 'fs-extra';
+import { getSiteResourceId } from '../site-metadata.js';
+export default class StaticResourceProvider {
+    constructor(_config, context) {
+        this.name = 'static-resource-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        this.resourceRegistry = context.resourceRegistry;
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.siteMetadata = context.siteMetadata;
+    }
+    async getResource(resourceIdentity, runtimeEnvironment, runtimeParams) {
+        const { debug } = runtimeEnvironment;
+        // HACK: this code is tricky because resource IDs are different between prod vs debug ("lwr-loader-shim.bundle.min.js" vs "lwr-loader-shim.bundle.js").
+        // 1. In debug mode on Lambda (during SSR), we need to ignore runtimeEnvironment.debug because we will always ask for the prod version (lwr-loader-shim.bundle.min.js)
+        // 2. But when we generate the view, we can't ignore runtimeEnvironment.debug because we need the debug version of the loader shim (lwr-loader-shim.bundle.js)
+        const { ignoreDebug } = runtimeParams;
+        const resourceMetadata = this.siteMetadata
+            .getSiteResourcesDecisionTree()
+            .find(getSiteResourceId(resourceIdentity), debug && !ignoreDebug);
+        if (!resourceMetadata) {
+            logger.warn({
+                label: `${this.name}`,
+                message: `Did not find requested specifier ${resourceIdentity.specifier}`,
+            });
+            return undefined;
+        }
+        const resourcePath = joinUrlPath(this.siteRootDir, resourceMetadata.path);
+        // Figure out mime type
+        const type = resourceMetadata.mimeType ||
+            mimeLookup(resourcePath) ||
+            'application/javascript';
+        return {
+            type,
+            stream: () => {
+                logger.debug({
+                    label: `${this.name}`,
+                    message: `Resource read from lambda ${resourceIdentity.specifier}`,
+                });
+                return fs.createReadStream(resourcePath);
+            },
+            src: resourcePath,
+            inline: resourceMetadata.inline,
+            integrity: resourceMetadata.integrity,
+            entry: path.resolve(resourcePath),
+        };
+    }
+}
+//# sourceMappingURL=static-resource-provider.js.map