@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.10 → 3.2.0-ultramodern.100

package/dist/cjs/plugins/deploy/platforms/cloudflare.js

@@ -0,0 +1,222 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCloudflarePreset: ()=>createCloudflarePreset
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../utils/index.js");
+const WORKER_ENTRY = 'server/index.mjs';
+const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const ASSETS_BINDING = 'ASSETS';
+const ROUTE_SPEC_FILE = 'route.json';
+const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const PUBLIC_ASSETS_DIRECTORY = 'public';
+const WORKER_BUNDLE_DIRECTORY = 'worker';
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const getCompatibilityDate = ()=>new Date().toISOString().slice(0, 10);
+const getWorkerName = (appDirectory)=>{
+    const basename = external_node_path_default().basename(appDirectory);
+    return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
+};
+const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
+    const configuredName = modernConfig.deploy?.worker?.name?.trim();
+    return configuredName || getWorkerName(appDirectory);
+};
+const readRouteSpec = async (outputDirectory)=>{
+    const routeSpecPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    if (!await utils_namespaceObject.fs.pathExists(routeSpecPath)) return {
+        routes: []
+    };
+    const routeSpec = await utils_namespaceObject.fs.readJSON(routeSpecPath);
+    return {
+        ...routeSpec,
+        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
+    };
+};
+const createWorkerManifest = async (outputDirectory, modernConfig)=>{
+    const routeSpec = await readRouteSpec(outputDirectory);
+    const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
+        const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        return {
+            urlPath: route.urlPath,
+            entryName: route.entryName,
+            entryPath: route.entryPath,
+            isSSR: Boolean(route.isSSR),
+            worker,
+            workerExists: worker ? await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, worker)) : false
+        };
+    }));
+    const bffPrefix = modernConfig.bff?.prefix;
+    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
+    const isEffectBff = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectBffWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    return {
+        version: 1,
+        runtime: {
+            type: 'cloudflare-module-worker',
+            entry: WORKER_ENTRY,
+            fetchExport: true,
+            nodeListen: false
+        },
+        assets: {
+            binding: ASSETS_BINDING,
+            directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+            runWorkerFirst: true
+        },
+        routeSpec: {
+            file: ROUTE_SPEC_OUTPUT,
+            routes
+        },
+        workerBundles: {
+            directory: WORKER_BUNDLE_DIRECTORY,
+            format: 'commonjs',
+            importableFromModuleWorker: true,
+            requestHandlerExport: 'requestHandler'
+        },
+        resources: {
+            loadableStats: LOADABLE_STATS_FILE,
+            routeManifest: ROUTE_MANIFEST_FILE
+        },
+        bff: isEffectBff && primaryBffPrefix && effectBffWorkerExists ? {
+            runtimeFramework: 'effect',
+            prefix: primaryBffPrefix,
+            worker: BFF_EFFECT_WORKER_ENTRY
+        } : void 0
+    };
+};
+const createWorkerModuleLoaders = (manifest)=>{
+    const imports = new Map();
+    for (const route of manifest.routeSpec.routes)if (route.worker && route.workerExists) {
+        const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
+        imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (manifest.bff?.worker) {
+        const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;
+        imports.set(manifest.bff.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (0 === imports.size) return '{}';
+    const loaders = [
+        ...imports.entries()
+    ].map(([worker, loader])=>`${JSON.stringify(worker)}: ${loader}`);
+    return `{\n${loaders.join(',\n')}\n}`;
+};
+const shouldCopyToPublicAssets = (src, distDirectory)=>{
+    const relativePath = external_node_path_default().relative(distDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const [topLevelDirectory] = normalizedRelativePath.split('/');
+    return normalizedRelativePath !== ROUTE_SPEC_FILE && topLevelDirectory !== WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== SERVER_BUNDLE_DIRECTORY;
+};
+const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
+    const relativePath = external_node_path_default().relative(workerBundleDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const basename = external_node_path_default().basename(normalizedRelativePath);
+    if (basename.startsWith('.') || normalizedRelativePath.includes('/.')) return false;
+    if (utils_namespaceObject.fs.statSync(src).isDirectory()) return true;
+    return [
+        '.cjs',
+        '.js',
+        '.mjs'
+    ].includes(external_node_path_default().extname(normalizedRelativePath));
+};
+const createCloudflarePreset = ({ appContext, modernConfig })=>{
+    const { appDirectory, distDirectory } = appContext;
+    const outputDirectory = external_node_path_default().join(appDirectory, '.output');
+    const publicDirectory = external_node_path_default().join(outputDirectory, PUBLIC_ASSETS_DIRECTORY);
+    const workerEntryPath = external_node_path_default().join(outputDirectory, WORKER_ENTRY);
+    const workerManifestPath = external_node_path_default().join(outputDirectory, WORKER_MANIFEST);
+    const routeSpecOutputPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    const wranglerConfigPath = external_node_path_default().join(outputDirectory, 'wrangler.json');
+    const workerName = getConfiguredWorkerName(appDirectory, modernConfig);
+    return {
+        async prepare () {
+            await utils_namespaceObject.fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await utils_namespaceObject.fs.copy(distDirectory, publicDirectory, {
+                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory)
+            });
+            await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerEntryPath));
+            await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerManifestPath));
+            const routeSpecSourcePath = external_node_path_default().join(distDirectory, ROUTE_SPEC_FILE);
+            if (await utils_namespaceObject.fs.pathExists(routeSpecSourcePath)) await utils_namespaceObject.fs.copy(routeSpecSourcePath, routeSpecOutputPath);
+            const workerBundleSourceDirectory = external_node_path_default().join(distDirectory, WORKER_BUNDLE_DIRECTORY);
+            if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, external_node_path_default().join(outputDirectory, WORKER_BUNDLE_DIRECTORY), {
+                filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
+            });
+            await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, {
+                $schema: 'node_modules/wrangler/config-schema.json',
+                name: workerName,
+                main: WORKER_ENTRY,
+                compatibility_date: getCompatibilityDate(),
+                compatibility_flags: [
+                    'nodejs_compat',
+                    'global_fetch_strictly_public'
+                ],
+                assets: {
+                    directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+                    binding: ASSETS_BINDING,
+                    run_worker_first: true
+                }
+            }, {
+                spaces: 2
+            });
+            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
+                spaces: 2
+            });
+            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, 'package.json'), {
+                type: 'commonjs'
+            });
+        },
+        async genEntry () {
+            const template = await (0, index_js_namespaceObject.readTemplate)('cloudflare-entry.mjs');
+            const manifest = await utils_namespaceObject.fs.readJSON(workerManifestPath);
+            await utils_namespaceObject.fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
+        }
+    };
+};
+exports.createCloudflarePreset = __webpack_exports__.createCloudflarePreset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCloudflarePreset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -0,0 +1,438 @@
+const ASSETS_BINDING = 'ASSETS';
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
+const workerModulePromises = new Map();
+const remoteJsonPromises = new Map();
+const CORS_HEADERS = {
+    'access-control-allow-headers': '*',
+    'access-control-allow-methods': 'GET, HEAD, OPTIONS',
+    'access-control-allow-origin': '*'
+};
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';
+function withCorsHeaders(response) {
+    const headers = new Headers(response.headers);
+    for (const [name, value] of Object.entries(CORS_HEADERS))if (!headers.has(name)) headers.set(name, value);
+    return new Response(response.body, {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+}
+function isFingerprintedAssetPathname(pathname) {
+    return /(?:^|\/)[^/]+\.[a-f0-9]{8,}\.(?:css|js|mjs|json|svg|png|jpe?g|webp|avif|gif|woff2?|ttf)$/iu.test(pathname);
+}
+function withAssetHeaders(response, request) {
+    const corsResponse = withCorsHeaders(response);
+    const headers = new Headers(corsResponse.headers);
+    const { pathname } = new URL(request.url);
+    if (isFingerprintedAssetPathname(pathname)) headers.set('cache-control', 'public, max-age=31536000, immutable');
+    return new Response(corsResponse.body, {
+        headers,
+        status: corsResponse.status,
+        statusText: corsResponse.statusText
+    });
+}
+function createCorsPreflightResponse(request) {
+    if ('OPTIONS' !== request.method) return null;
+    return new Response(null, {
+        headers: CORS_HEADERS,
+        status: 204
+    });
+}
+async function fetchAsset(request, env) {
+    const assets = env?.[ASSETS_BINDING];
+    if (!assets || 'function' != typeof assets.fetch) return null;
+    const response = await assets.fetch(request);
+    if (404 === response.status) return null;
+    return withAssetHeaders(response, request);
+}
+async function fetchAssetByPath(pathname, request, env) {
+    const url = new URL(request.url);
+    url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
+    return fetchAsset(new Request(url, request), env);
+}
+async function fetchAssetByPathFollowingRedirects(pathname, request, env, visited = new Set()) {
+    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    if (visited.has(normalizedPathname)) return null;
+    visited.add(normalizedPathname);
+    const response = await fetchAssetByPath(normalizedPathname, request, env);
+    if (response && response.status >= 300 && response.status < 400 && response.headers.has('location')) {
+        const location = response.headers.get('location');
+        if (location) {
+            const nextUrl = new URL(location, request.url);
+            const currentUrl = new URL(request.url);
+            if (nextUrl.origin === currentUrl.origin) return fetchAssetByPathFollowingRedirects(nextUrl.pathname, request, env, visited);
+        }
+    }
+    return response;
+}
+async function readAssetText(pathname, request, env) {
+    const response = await fetchAssetByPathFollowingRedirects(pathname, request, env);
+    if (!response || !response.ok) return;
+    return response.text();
+}
+async function readAssetJson(pathname, request, env) {
+    const text = await readAssetText(pathname, request, env);
+    if (!text) return {};
+    return JSON.parse(text);
+}
+function normalizeRoutePath(pathname) {
+    if ('/' === pathname) return pathname;
+    return pathname.replace(/\/+$/u, '');
+}
+function getPathExtension(pathname) {
+    const lastSegment = pathname.split('/').pop() || '';
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (dotIndex <= 0 || dotIndex === lastSegment.length - 1) return '';
+    return lastSegment.slice(dotIndex).toLowerCase();
+}
+function isAssetLikePathname(pathname) {
+    const extension = getPathExtension(pathname);
+    return '' !== extension && '.html' !== extension && '.htm' !== extension;
+}
+function routeMatchesExactly(route, pathname) {
+    if ('string' != typeof route?.urlPath) return false;
+    return normalizeRoutePath(route.urlPath) === normalizeRoutePath(pathname);
+}
+function routeMatches(route, pathname) {
+    if ('string' != typeof route.urlPath) return false;
+    const routePath = normalizeRoutePath(route.urlPath);
+    const requestPath = normalizeRoutePath(pathname);
+    return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
+}
+function findRoute(request) {
+    const { pathname } = new URL(request.url);
+    const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
+    return [
+        ...routes
+    ].sort((left, right)=>{
+        const leftLength = left.urlPath?.length || 0;
+        const rightLength = right.urlPath?.length || 0;
+        return rightLength - leftLength;
+    }).find((route)=>routeMatches(route, pathname));
+}
+async function fetchRouteHtml(route, request, env) {
+    if (!route?.entryPath) return null;
+    return fetchAssetByPath(route.entryPath, request, env);
+}
+function createNoopMonitors() {
+    const noop = ()=>{};
+    return {
+        debug: noop,
+        error: noop,
+        info: noop,
+        warn: noop
+    };
+}
+function createRequestHandlerOptions({ route, htmlTemplate, routeManifest, loadableStats }) {
+    const monitors = createNoopMonitors();
+    return {
+        resource: {
+            route,
+            routeManifest,
+            loadableStats,
+            htmlTemplate,
+            entryName: route.entryName
+        },
+        params: {},
+        loaderContext: {},
+        config: {},
+        locals: {},
+        staticGenerate: false,
+        monitors,
+        onError (error) {
+            monitors.error(error);
+        },
+        onTiming () {},
+        reporter: {
+            reportTiming: ()=>{}
+        }
+    };
+}
+function collectRouteCssAssets(route, routeManifest) {
+    const routeAssets = routeManifest?.routeAssets || {};
+    const candidateKeys = [
+        route.entryName,
+        `async-${route.entryName}`
+    ].filter(Boolean);
+    const assets = new Set();
+    for (const key of candidateKeys){
+        const routeAsset = routeAssets[key];
+        const cssAssets = [
+            ...Array.isArray(routeAsset?.referenceCssAssets) ? routeAsset.referenceCssAssets : [],
+            ...Array.isArray(routeAsset?.assets) ? routeAsset.assets : []
+        ];
+        for (const asset of cssAssets)if ('string' == typeof asset && asset.endsWith('.css')) assets.add(asset);
+    }
+    return [
+        ...assets
+    ];
+}
+function collectRenderedFederatedExposes(html) {
+    const renderedExposes = [];
+    const tagPattern = /<[^>]*data-modern-(?:boundary-id|mf-expose)=["'][^"']+["'][^>]*>/g;
+    const attributePattern = /\s(data-modern-(?:boundary-id|mf-expose))=["']([^"']+)["']/g;
+    for (const [tag] of html.matchAll(tagPattern)){
+        const attributes = {};
+        for (const [, name, value] of tag.matchAll(attributePattern))attributes[name] = value;
+        const boundaryId = attributes['data-modern-boundary-id'];
+        const expose = attributes['data-modern-mf-expose'];
+        if (boundaryId && expose) renderedExposes.push({
+            boundaryId,
+            expose
+        });
+    }
+    return renderedExposes;
+}
+function getRemoteManifestUrl(remote, request) {
+    const entry = remote?.entry;
+    if ('string' != typeof entry || 0 === entry.length) return;
+    return new URL(entry, request.url).toString();
+}
+async function fetchRemoteJson(jsonUrl) {
+    if (!remoteJsonPromises.has(jsonUrl)) remoteJsonPromises.set(jsonUrl, fetch(jsonUrl).then((response)=>{
+        if (!response.ok) {
+            remoteJsonPromises.delete(jsonUrl);
+            return {};
+        }
+        return response.json().catch(()=>{
+            remoteJsonPromises.delete(jsonUrl);
+            return {};
+        });
+    }).catch(()=>{
+        remoteJsonPromises.delete(jsonUrl);
+        return {};
+    }));
+    return remoteJsonPromises.get(jsonUrl);
+}
+function findRemoteExpose(remoteManifest, exposePath) {
+    const exposes = Array.isArray(remoteManifest?.exposes) ? remoteManifest.exposes : [];
+    const normalizedExpose = exposePath.replace(/^\.\//u, '');
+    return exposes.find((expose)=>{
+        if (!expose || 'object' != typeof expose) return false;
+        return expose.path === exposePath || expose.path === `./${normalizedExpose}` || expose.name === normalizedExpose;
+    });
+}
+function collectCssAssetEntries(assets) {
+    const cssAssets = assets?.css;
+    return [
+        ...Array.isArray(cssAssets?.sync) ? cssAssets.sync : [],
+        ...Array.isArray(cssAssets?.async) ? cssAssets.async : []
+    ].filter((asset)=>'string' == typeof asset && asset.endsWith('.css'));
+}
+function collectRouteManifestCssAssets(routeManifest) {
+    const routeAssets = routeManifest?.routeAssets || {};
+    const assets = new Set();
+    for (const routeAsset of Object.values(routeAssets)){
+        const cssAssets = [
+            ...Array.isArray(routeAsset?.referenceCssAssets) ? routeAsset.referenceCssAssets : [],
+            ...Array.isArray(routeAsset?.assets) ? routeAsset.assets : []
+        ];
+        for (const asset of cssAssets)if ('string' == typeof asset && asset.endsWith('.css')) assets.add(asset);
+    }
+    return [
+        ...assets
+    ];
+}
+async function collectRenderedRemoteCssHrefs(html, request, env) {
+    const renderedExposes = collectRenderedFederatedExposes(html);
+    if (0 === renderedExposes.length) return [];
+    const hostManifest = await readAssetJson('mf-manifest.json', request, env);
+    const remotes = Array.isArray(hostManifest?.remotes) ? hostManifest.remotes : [];
+    const remoteByBoundary = new Map();
+    const hrefs = new Set();
+    for (const remote of remotes){
+        if ('string' == typeof remote?.alias) remoteByBoundary.set(remote.alias, remote);
+        if ('string' == typeof remote?.federationContainerName) remoteByBoundary.set(remote.federationContainerName, remote);
+    }
+    await Promise.all(renderedExposes.map(async ({ boundaryId, expose })=>{
+        const remote = remoteByBoundary.get(boundaryId);
+        const manifestUrl = remote ? getRemoteManifestUrl(remote, request) : void 0;
+        if (!manifestUrl) return;
+        const remoteManifest = await fetchRemoteJson(manifestUrl);
+        const remoteExpose = findRemoteExpose(remoteManifest, expose);
+        const publicPath = 'string' == typeof remoteManifest?.metaData?.publicPath ? remoteManifest.metaData.publicPath : manifestUrl;
+        const remoteRouteManifest = await fetchRemoteJson(new URL('routes-manifest.json', publicPath).toString());
+        for (const asset of collectCssAssetEntries(remoteExpose?.assets))hrefs.add(new URL(asset, publicPath).toString());
+        for (const asset of collectRouteManifestCssAssets(remoteRouteManifest))hrefs.add(new URL(asset, publicPath).toString());
+    }));
+    return [
+        ...hrefs
+    ];
+}
+function escapeAttribute(value) {
+    return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+async function withRouteCssLinks(response, route, routeManifest, request, env) {
+    const contentType = response.headers.get('content-type') || '';
+    if (!contentType.includes('text/html')) return response;
+    const html = await response.text();
+    const cssHrefs = [
+        ...collectRouteCssAssets(route, routeManifest).map((asset)=>new URL(asset, request.url).toString()),
+        ...await collectRenderedRemoteCssHrefs(html, request, env)
+    ];
+    if (0 === cssHrefs.length) return response;
+    const uniqueCssHrefs = [
+        ...new Set(cssHrefs)
+    ];
+    const headers = new Headers(response.headers);
+    for (const href of uniqueCssHrefs)headers.append('link', `<${href}>; rel=preload; as=style`);
+    const links = uniqueCssHrefs.filter((href)=>!html.includes(href)).map((href)=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
+    if (0 === links.length || !html.includes('</head>')) return new Response(html, {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+    return new Response(html.replace('</head>', `${links.join('')}</head>`), {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+}
+async function getRequestHandlerOptions(route, request, env) {
+    const [htmlTemplate, routeManifest, loadableStats] = await Promise.all([
+        readAssetText(route.entryPath, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.routeManifest, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.loadableStats, request, env)
+    ]);
+    return createRequestHandlerOptions({
+        route,
+        htmlTemplate: htmlTemplate || '',
+        routeManifest,
+        loadableStats
+    });
+}
+async function loadWorkerModule(workerPath) {
+    const loader = WORKER_MODULE_LOADERS[workerPath];
+    if (!loader) return;
+    if (!workerModulePromises.has(workerPath)) workerModulePromises.set(workerPath, loader());
+    return workerModulePromises.get(workerPath);
+}
+function getRuntimeModule(workerModule) {
+    const defaultExport = workerModule.default;
+    const nestedDefaultExport = defaultExport && 'object' == typeof defaultExport ? defaultExport.default : void 0;
+    return defaultExport && 'object' == typeof defaultExport ? {
+        ...workerModule,
+        ...defaultExport,
+        ...nestedDefaultExport && 'object' == typeof nestedDefaultExport ? nestedDefaultExport : {}
+    } : workerModule;
+}
+function getFetchHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    const runtime = getRuntimeModule(workerModule);
+    return 'function' == typeof runtime.fetch && runtime.fetch.bind(runtime) || 'function' == typeof defaultExport && defaultExport.fetch?.bind?.(defaultExport);
+}
+async function getRequestHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    const runtime = getRuntimeModule(workerModule);
+    return await workerModule.requestHandler || await runtime.requestHandler || ('function' == typeof defaultExport ? defaultExport : void 0);
+}
+async function dispatchRouteWorker(route, request, env, ctx) {
+    const workerPath = route.worker;
+    if (!workerPath) return new Response('Worker bundle not configured for SSR route', {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8'
+        }
+    });
+    const workerModule = await loadWorkerModule(workerPath);
+    if (!workerModule) return new Response(`Worker bundle not found: ${workerPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': workerPath
+        }
+    });
+    const fetchHandler = getFetchHandler(workerModule);
+    if (fetchHandler) return fetchHandler(request, env, ctx);
+    const requestHandler = await getRequestHandler(workerModule);
+    if ('function' == typeof requestHandler) {
+        const requestHandlerOptions = await getRequestHandlerOptions(route, request, env);
+        return withRouteCssLinks(await requestHandler(request, requestHandlerOptions), route, requestHandlerOptions.resource.routeManifest, request, env);
+    }
+    return new Response(`Worker bundle has no fetch or requestHandler export: ${workerPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': workerPath
+        }
+    });
+}
+function matchesPrefix(pathname, prefix) {
+    if (!prefix || '/' === prefix) return true;
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createRequestForMountedPrefix(request, prefix) {
+    if (!prefix || '/' === prefix) return request;
+    const url = new URL(request.url);
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    if (!matchesPrefix(url.pathname, normalized)) return request;
+    const nextPath = url.pathname.slice(normalized.length) || '/';
+    url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
+    return new Request(url, request);
+}
+function createEffectContext(originalRequest, mountedRequest, env) {
+    const url = new URL(originalRequest.url);
+    return {
+        request: mountedRequest,
+        env: env || {},
+        path: url.pathname,
+        method: originalRequest.method,
+        operationContext: {
+            request: mountedRequest,
+            env: env || {},
+            path: url.pathname,
+            method: originalRequest.method
+        }
+    };
+}
+async function dispatchBffRequest(request, env) {
+    const bff = MODERN_WORKER_MANIFEST.bff;
+    if (!bff?.worker || !matchesPrefix(new URL(request.url).pathname, bff.prefix)) return null;
+    const workerModule = await loadWorkerModule(bff.worker);
+    if (!workerModule) return new Response(`BFF worker bundle not found: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    const mountedRequest = createRequestForMountedPrefix(request, bff.prefix);
+    const effectContext = createEffectContext(request, mountedRequest, env);
+    const defaultExport = workerModule.default;
+    const runtime = getRuntimeModule(workerModule);
+    const directHandler = 'function' == typeof runtime.handler && runtime.handler || 'function' == typeof defaultExport && defaultExport;
+    const createdHandler = 'function' == typeof runtime.createHandler ? runtime.createHandler().handler : void 0;
+    const handler = directHandler || createdHandler;
+    if ('function' != typeof handler) return new Response(`BFF worker bundle has no handler export: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    return handler.length > 1 ? handler(mountedRequest, effectContext) : handler(mountedRequest);
+}
+export default {
+    async fetch (request, env, ctx) {
+        const corsPreflightResponse = createCorsPreflightResponse(request);
+        if (corsPreflightResponse) return corsPreflightResponse;
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return assetResponse;
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return withCorsHeaders(bffResponse);
+        const route = findRoute(request);
+        const { pathname } = new URL(request.url);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) return withCorsHeaders(new Response('Not found', {
+            status: 404
+        }));
+        if (route?.worker) return withCorsHeaders(await dispatchRouteWorker(route, request, env, ctx));
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return htmlResponse;
+        return withCorsHeaders(new Response('Not found', {
+            status: 404
+        }));
+    }
+};

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-worker-fs-promises.mjs

@@ -0,0 +1,7 @@
+const unavailable = (method)=>async ()=>{
+        throw new Error(`node:fs/promises.${method} is unavailable in Cloudflare Worker SSR`);
+    };
+export const readFile = unavailable('readFile');
+export default {
+    readFile
+};