@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.3 → 3.5.0-ultramodern.30

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

@@ -2,6 +2,8 @@ const ASSETS_BINDING = 'ASSETS';
 const MODERN_WORKER_MANIFEST = p_workerManifest;
 const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
 const workerModulePromises = new Map();
+const effectBffDispatcherPromises = new Map();
+let effectEdgeRuntimePromise;
 const remoteJsonPromises = new Map();
 const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
 const ASSET_CORS_ENABLED = false !== CORS_POLICY.assets;
@@ -150,19 +152,10 @@ async function createCorsPreflightResponse(request, env) {
             status: 204
         });
     }
-    if (!ASSET_CORS_ENABLED) return null;
-    const assets = env?.[ASSETS_BINDING];
-    if (!assets || 'function' != typeof assets.fetch) return null;
-    const assetResponse = await assets.fetch(new Request(request.url, {
-        method: 'HEAD'
-    }));
-    if (!assetResponse || 404 === assetResponse.status) return null;
-    return new Response(null, {
-        headers: ASSET_CORS_HEADERS,
-        status: 204
-    });
+    return null;
 }
 async function fetchAsset(request, env) {
+    if ('GET' !== request.method && 'HEAD' !== request.method) return null;
     const assets = env?.[ASSETS_BINDING];
     if (!assets || 'function' != typeof assets.fetch) return null;
     const response = await assets.fetch(request);
@@ -211,7 +204,7 @@ function getPathExtension(pathname) {
 }
 function isAssetLikePathname(pathname) {
     const extension = getPathExtension(pathname);
-    return '' !== extension && '.html' !== extension && '.htm' !== extension;
+    return '' !== extension;
 }
 function routeMatchesExactly(route, pathname) {
     if ('string' != typeof route?.urlPath) return false;
@@ -223,6 +216,255 @@ function routeMatches(route, pathname) {
     const requestPath = normalizeRoutePath(pathname);
     return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
 }
+function getRouteI18nEntry(route) {
+    if (!route || 'string' != typeof route.entryName) return;
+    return MODERN_WORKER_MANIFEST.i18n?.entries?.[route.entryName];
+}
+function getRouteBasePath(route) {
+    const routePath = 'string' == typeof route?.urlPath ? normalizeRoutePath(route.urlPath) : '/';
+    return routePath || '/';
+}
+function getRouteRemainingPathname(route, pathname) {
+    const basePath = getRouteBasePath(route);
+    if ('/' === basePath) return pathname || '/';
+    if (!matchesPrefix(pathname, basePath)) return pathname || '/';
+    const remaining = pathname.slice(basePath.length);
+    return remaining ? remaining.startsWith('/') ? remaining : `/${remaining}` : '/';
+}
+function normalizeLanguage(value, languages) {
+    if ('string' != typeof value || '' === value.trim()) return null;
+    const normalized = value.trim().toLowerCase();
+    const exact = languages.find((language)=>language.toLowerCase() === normalized);
+    if (exact) return exact;
+    const baseLanguage = normalized.split(/[-_]/u)[0];
+    return languages.find((language)=>language.toLowerCase() === baseLanguage) || null;
+}
+function getLanguageFromPath(route, pathname, languages) {
+    const remainingPathname = getRouteRemainingPathname(route, pathname);
+    const firstSegment = remainingPathname.split('/').filter(Boolean)[0];
+    return normalizeLanguage(firstSegment, languages);
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return value;
+    }
+}
+function detectLanguageFromCookie(cookieHeader, lookupCookie, languages) {
+    if (!cookieHeader) return null;
+    for (const cookiePart of cookieHeader.split(';')){
+        const [rawName, ...rawValue] = cookiePart.trim().split('=');
+        if (rawName === lookupCookie && 0 !== rawValue.length) return normalizeLanguage(safeDecodeURIComponent(rawValue.join('=')), languages);
+    }
+    return null;
+}
+function detectLanguageFromAcceptLanguage(acceptLanguage, languages) {
+    if (!acceptLanguage) return null;
+    return acceptLanguage.split(',').map((entry, index)=>{
+        const [rawRange, ...rawParameters] = entry.trim().split(';');
+        const qualityParameter = rawParameters.find((parameter)=>parameter.trim().startsWith('q='));
+        const quality = qualityParameter ? Number.parseFloat(qualityParameter.split('=')[1] || '') : 1;
+        return {
+            index,
+            language: normalizeLanguage(rawRange, languages),
+            quality: Number.isFinite(quality) ? quality : 1
+        };
+    }).filter((candidate)=>candidate.language && candidate.quality > 0).sort((left, right)=>right.quality - left.quality || left.index - right.index)[0]?.language || null;
+}
+function detectRedirectLanguage(request, entry) {
+    if (!entry.i18nextDetector) return null;
+    const url = new URL(request.url);
+    const detection = entry.detection || {};
+    const order = Array.isArray(detection.order) ? detection.order : [
+        'querystring',
+        'cookie',
+        'header'
+    ];
+    for (const method of order){
+        const language = 'querystring' === method ? normalizeLanguage(url.searchParams.get(detection.lookupQuerystring || 'lng'), entry.languages) : 'cookie' === method ? detectLanguageFromCookie(request.headers.get('cookie'), detection.lookupCookie || 'i18next', entry.languages) : 'header' === method ? detectLanguageFromAcceptLanguage(request.headers.get(detection.lookupHeader || 'accept-language'), entry.languages) : null;
+        if (language) return language;
+    }
+    return null;
+}
+function normaliseSlashes(pathname) {
+    const withoutDuplicateSlashes = pathname.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/u, '') : withLeadingSlash;
+}
+function normalisePathPattern(pathname) {
+    return normaliseSlashes(pathname).replace(/\[(.+?)\]/g, ':$1');
+}
+function stripLanguagePrefix(pathname, languages) {
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (firstSegment && normalizeLanguage(firstSegment, languages)) return `/${segments.slice(1).join('/')}` || '/';
+    return pathname || '/';
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getPatternParamName(segment) {
+    return segment.slice(1).replace(/\?$/, '');
+}
+function compilePathPattern(pattern) {
+    const names = [];
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getPatternParamName(segment));
+            return segment.endsWith('?') ? '(?:/([^/]+))?' : '/([^/]+)';
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    return {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+}
+function matchPathPattern(pathname, pattern) {
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normaliseSlashes(pathname));
+    if (!match) return null;
+    const params = {};
+    for(let index = 0; index < names.length; index++)try {
+        params[names[index]] = decodeURIComponent(match[index + 1] || '');
+    } catch  {
+        return null;
+    }
+    return params;
+}
+function buildPathFromPattern(pattern, params) {
+    const path = normalisePathPattern(pattern).split('/').filter(Boolean).map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getPatternParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return params['*'] || '';
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+}
+function patternSpecificity(pattern) {
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        dynamicSegments,
+        splatSegments,
+        staticSegments,
+        totalSegments: segments.length
+    };
+}
+function comparePatternSpecificity(left, right) {
+    const leftSpecificity = patternSpecificity(left);
+    const rightSpecificity = patternSpecificity(right);
+    return rightSpecificity.staticSegments - leftSpecificity.staticSegments || rightSpecificity.totalSegments - leftSpecificity.totalSegments || leftSpecificity.splatSegments - rightSpecificity.splatSegments || leftSpecificity.dynamicSegments - rightSpecificity.dynamicSegments;
+}
+function sortLocalisedPatterns(patterns) {
+    return patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+}
+function resolveLocalisedPath(pathname, targetLanguage, languages, localisedUrls) {
+    const normalizedPathname = normaliseSlashes(pathname);
+    const canonicalCandidates = sortLocalisedPatterns(Object.entries(localisedUrls || {}).map(([canonicalPattern, localisedUrlEntry])=>({
+            canonicalPattern,
+            localisedUrlEntry,
+            pattern: canonicalPattern
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        const params = targetPattern ? matchPathPattern(normalizedPathname, canonicalPattern) : null;
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    const localisedCandidates = sortLocalisedPatterns(Object.values(localisedUrls || {}).flatMap((localisedUrlEntry)=>{
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter(Boolean).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+}
+function localiseTargetPathname(pathname, language, languages, localisedUrls) {
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const resolvedPath = localisedUrls ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrls) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+}
+function shouldIgnoreLocaleRedirect(pathname, route, entry) {
+    const remainingPathname = getRouteRemainingPathname(route, pathname);
+    const normalizedPathname = remainingPathname.startsWith('/') ? remainingPathname : `/${remainingPathname}`;
+    const ignoredPrefixes = [
+        ...entry.ignoreRedirectRoutes || [],
+        ...entry.staticRoutePrefixes || [],
+        '/static',
+        '/upload'
+    ];
+    return ignoredPrefixes.some((prefix)=>{
+        const normalizedPrefix = normaliseSlashes(prefix);
+        return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+    });
+}
+function buildLocalizedUrl(route, request, language, entry) {
+    const url = new URL(request.url);
+    const basePath = getRouteBasePath(route);
+    const remainingPathname = getRouteRemainingPathname(route, url.pathname);
+    const localizedPathname = localiseTargetPathname(remainingPathname, language, entry.languages, entry.localisedUrls);
+    const nextPathname = '/' === basePath ? localizedPathname : normaliseSlashes(`${basePath}/${localizedPathname}`);
+    return `${nextPathname}${url.search}`;
+}
+function createLocaleRedirectResponse(location, entry) {
+    const headers = new Headers({
+        'cache-control': 'private, no-store',
+        location
+    });
+    const vary = [];
+    const detectionOrder = entry.i18nextDetector ? entry.detection?.order || [] : [];
+    if (detectionOrder.includes('header')) vary.push('Accept-Language');
+    if (detectionOrder.includes('cookie')) vary.push('Cookie');
+    if (vary.length > 0) headers.set('vary', vary.join(', '));
+    return new Response(null, {
+        headers,
+        status: 302
+    });
+}
+function createLocaleRedirectResponseForRequest(route, request) {
+    const entry = getRouteI18nEntry(route);
+    if (!entry || !Array.isArray(entry.languages) || 0 === entry.languages.length) return null;
+    const { pathname, search } = new URL(request.url);
+    if (isAssetLikePathname(pathname)) return null;
+    if (shouldIgnoreLocaleRedirect(pathname, route, entry)) return null;
+    const language = getLanguageFromPath(route, pathname, entry.languages);
+    if (!language) {
+        const targetLanguage = detectRedirectLanguage(request, entry) || entry.fallbackLanguage;
+        return createLocaleRedirectResponse(buildLocalizedUrl(route, request, targetLanguage, entry), entry);
+    }
+    if (entry.localisedUrls) {
+        const expectedUrl = buildLocalizedUrl(route, request, language, entry);
+        if (expectedUrl !== `${pathname}${search}`) return createLocaleRedirectResponse(expectedUrl, entry);
+    }
+    return null;
+}
 function findRoute(request) {
     const { pathname } = new URL(request.url);
     const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
@@ -399,21 +641,40 @@ async function collectRenderedRemoteCssHrefs(html, request, env) {
 function escapeAttribute(value) {
     return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
+function isAbsoluteUrl(value) {
+    return /^[a-z][a-z\d+.-]*:/iu.test(value);
+}
+function toRouteCssHtmlHref(asset) {
+    if (isAbsoluteUrl(asset) || asset.startsWith('/')) return asset;
+    return `/${asset.replace(/^\/+/u, '')}`;
+}
 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 cssEntries = [
+        ...collectRouteCssAssets(route, routeManifest).map((asset)=>{
+            const href = toRouteCssHtmlHref(asset);
+            return {
+                href,
+                preloadHref: new URL(href, request.url).toString()
+            };
+        }),
+        ...(await collectRenderedRemoteCssHrefs(html, request, env)).map((href)=>({
+                href,
+                preloadHref: new URL(href, request.url).toString()
+            }))
     ];
+    if (0 === cssEntries.length) return response;
+    const seenCssHrefs = new Set();
+    const uniqueCssEntries = cssEntries.filter((entry)=>{
+        if (seenCssHrefs.has(entry.preloadHref)) return false;
+        seenCssHrefs.add(entry.preloadHref);
+        return true;
+    });
     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)}">`);
+    for (const { preloadHref } of uniqueCssEntries)headers.append('link', `<${preloadHref}>; rel=preload; as=style`);
+    const links = uniqueCssEntries.filter(({ href, preloadHref })=>!html.includes(href) && !html.includes(preloadHref)).map(({ href })=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
     if (0 === links.length || !html.includes('</head>')) return new Response(html, {
         headers,
         status: response.status,
@@ -444,6 +705,10 @@ async function loadWorkerModule(workerPath) {
     if (!workerModulePromises.has(workerPath)) workerModulePromises.set(workerPath, loader());
     return workerModulePromises.get(workerPath);
 }
+async function loadEffectEdgeRuntime() {
+    effectEdgeRuntimePromise ??= import('@modern-js/plugin-bff/effect-edge');
+    return effectEdgeRuntimePromise;
+}
 function getRuntimeModule(workerModule) {
     const defaultExport = workerModule.default;
     const nestedDefaultExport = defaultExport && 'object' == typeof defaultExport ? defaultExport.default : void 0;
@@ -508,21 +773,6 @@ function createRequestForMountedPrefix(request, prefix) {
     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;
@@ -535,9 +785,23 @@ async function dispatchBffRequest(request, env) {
         }
     });
     const mountedRequest = createRequestForMountedPrefix(request, bff.prefix);
-    const effectContext = createEffectContext(request, mountedRequest, env);
     const defaultExport = workerModule.default;
     const runtime = getRuntimeModule(workerModule);
+    if ('effect' === bff.runtimeFramework) {
+        let effectDispatcherPromise = effectBffDispatcherPromises.get(bff.worker);
+        if (!effectDispatcherPromise) {
+            const { createEffectBffEdgeDispatcher } = await loadEffectEdgeRuntime();
+            effectDispatcherPromise = createEffectBffEdgeDispatcher({
+                module: runtime,
+                prefix: bff.prefix
+            });
+            effectBffDispatcherPromises.set(bff.worker, effectDispatcherPromise);
+        }
+        const effectDispatcher = await effectDispatcherPromise;
+        return effectDispatcher.dispatch(request, {
+            env
+        });
+    }
     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;
@@ -548,27 +812,66 @@ async function dispatchBffRequest(request, env) {
             'x-modern-js-bff-worker': bff.worker
         }
     });
-    return handler.length > 1 ? handler(mountedRequest, effectContext) : handler(mountedRequest);
+    const effectContext = {
+        request: mountedRequest,
+        env: env || {},
+        path: new URL(request.url).pathname,
+        method: request.method,
+        operationContext: {
+            request: mountedRequest,
+            env: env || {},
+            path: new URL(request.url).pathname,
+            method: request.method
+        }
+    };
+    return handler(mountedRequest, effectContext);
+}
+async function dispatchServiceBindingRequest(request, env) {
+    const serviceBindings = MODERN_WORKER_MANIFEST.serviceBindings;
+    if (!Array.isArray(serviceBindings) || 0 === serviceBindings.length) return null;
+    const pathname = new URL(request.url).pathname;
+    for (const binding of serviceBindings){
+        if (!binding?.binding || !binding?.prefix) continue;
+        if (!matchesPrefix(pathname, binding.prefix)) continue;
+        const service = env?.[binding.binding];
+        if (!service || 'function' != typeof service.fetch) return new Response(`Cloudflare service binding not available: ${binding.binding}`, {
+            status: 502,
+            headers: {
+                'content-type': 'text/plain; charset=utf-8',
+                'x-modern-js-service-binding': binding.binding
+            }
+        });
+        return service.fetch(request);
+    }
+    return null;
 }
 export default {
     async fetch (request, env, ctx) {
         const corsPreflightResponse = await createCorsPreflightResponse(request, env);
         if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
-        const assetResponse = await fetchAsset(request, env);
-        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
         const bffResponse = await dispatchBffRequest(request, env);
         if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
+        const serviceBindingResponse = await dispatchServiceBindingRequest(request, env);
+        if (serviceBindingResponse) return finalizeResponseForRequest(withAppCorsHeaders(serviceBindingResponse, request), request);
         const route = findRoute(request);
         const { pathname } = new URL(request.url);
-        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
-            status: 404
-        }), request), request);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
+            const assetResponse = await fetchAsset(request, env);
+            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+                status: 404
+            }), request), request);
+        }
+        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
+        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
         if (route?.worker) {
             const renderableRequest = createRenderableRequest(request);
             return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
         }
         const htmlResponse = await fetchRouteHtml(route, request, env);
         if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
         return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
             status: 404
         }), request), request);

package/dist/types/plugins/backendFederationBuild.d.ts

@@ -0,0 +1,11 @@
+import type { AppTools, CliPlugin } from '../types';
+export type BackendFederationArtifactResult = {
+    appId: string;
+    manifestPath: string;
+    containerPath: string;
+    remoteName: string;
+    remoteType: string;
+};
+export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
+export default _default;
+declare function _default(): CliPlugin<AppTools>;

package/dist/types/plugins/deploy/platforms/cloudflare-output-contract.d.ts

@@ -0,0 +1,13 @@
+export declare const CLOUDFLARE_WORKER_ENTRY = "server/index.mjs";
+export declare const CLOUDFLARE_WORKER_MANIFEST = "server/modern-worker-manifest.json";
+export declare const CLOUDFLARE_WRANGLER_CONFIG_FILE = "wrangler.json";
+export declare const CLOUDFLARE_OUTPUT_PACKAGE_FILE = "package.json";
+export declare const CLOUDFLARE_WORKER_PACKAGE_FILE = "worker/package.json";
+export declare const CLOUDFLARE_ASSETS_BINDING = "ASSETS";
+export declare const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = "public";
+export declare const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = "worker";
+export declare const CLOUDFLARE_RUNTIME_TYPE = "cloudflare-module-worker";
+export declare const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = "module";
+export declare const CLOUDFLARE_WORKER_PACKAGE_TYPE = "commonjs";
+export declare const CLOUDFLARE_WORKER_BUNDLE_FORMAT = "commonjs";
+export declare const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: readonly ['nodejs_compat', 'global_fetch_strictly_public'];

package/dist/types/plugins/deploy/platforms/cloudflare-output-plan.d.ts

@@ -0,0 +1,33 @@
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_PACKAGE_TYPE } from './cloudflare-output-contract';
+export type CloudflareOutputPlan = {
+    outputDirectory: string;
+    requiredFiles: string[];
+    publicLeakDirectories: string[];
+    paths: {
+        workerEntry: string;
+        workerManifest: string;
+        wranglerConfig: string;
+        outputPackage: string;
+        workerPackage: string;
+        publicAssets: string;
+        workerBundle: string;
+    };
+    packages: {
+        output: {
+            type: typeof CLOUDFLARE_OUTPUT_PACKAGE_TYPE;
+        };
+        worker: {
+            type: typeof CLOUDFLARE_WORKER_PACKAGE_TYPE;
+        };
+    };
+    wrangler: {
+        main: typeof CLOUDFLARE_WORKER_ENTRY;
+        assets: {
+            binding: typeof CLOUDFLARE_ASSETS_BINDING;
+            directory: `./${typeof CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`;
+            run_worker_first: true;
+        };
+        requiredCompatibilityFlags: typeof CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+    };
+};
+export declare function createCloudflareOutputPlan(outputDirectory: string): CloudflareOutputPlan;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier.d.ts

@@ -0,0 +1,32 @@
+export type CloudflareOutputVerifierIssueCode = 'missing-file' | 'invalid-manifest' | 'invalid-wrangler' | 'invalid-package' | 'public-output-leak' | 'missing-worker-bundle' | 'invalid-worker-bundle' | 'worker-import-failed' | 'delivery-unit-drift' | 'missing-delivery-unit' | 'forbidden-mutation-pattern';
+export interface CloudflareOutputVerifierIssue {
+    code: CloudflareOutputVerifierIssueCode;
+    message: string;
+    path?: string;
+}
+export interface CloudflareDeliveryUnitIdentity {
+    unitId: string;
+    buildMarker: string;
+    sourceRevision: string;
+}
+export interface VerifyCloudflareOutputOptions {
+    outputDirectory: string;
+    importWorker?: boolean;
+    /**
+     * Topology-declared delivery-unit record (from the workspace compact config).
+     * When provided, the Cloudflare worker manifest must carry a matching
+     * `deliveryUnit` stamp so the deployed worker snapshot is proven to derive
+     * from the same delivery unit as the Node/API surfaces (ADR-0019 lane D).
+     */
+    deliveryUnit?: CloudflareDeliveryUnitIdentity;
+}
+export interface VerifyCloudflareOutputMutationPolicyOptions {
+    scanRoots: string[];
+}
+export interface CloudflareOutputVerifierResult {
+    ok: boolean;
+    issues: CloudflareOutputVerifierIssue[];
+}
+export declare const verifyCloudflareOutputMutationPolicy: (options: VerifyCloudflareOutputMutationPolicyOptions) => Promise<CloudflareOutputVerifierResult>;
+export declare const verifyCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<CloudflareOutputVerifierResult>;
+export declare const assertCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<void>;

package/dist/types/types/config/cloudflareDeploy.d.ts

@@ -14,6 +14,17 @@ export interface CloudflareWorkerArtifactConfig {
      */
     to: string;
 }
+export interface CloudflareWorkerPublicAssetConfig {
+    /**
+     * Source file or directory, relative to the app root, to copy into
+     * Cloudflare Worker Static Assets.
+     */
+    from: string;
+    /**
+     * Destination path relative to `.output/public`.
+     */
+    to: string;
+}
 export interface CloudflareWorkerD1DatabaseConfig {
     /**
      * Worker binding name, for example `DB`.
@@ -41,6 +52,17 @@ export interface CloudflareWorkerD1DatabaseConfig {
      */
     remote?: boolean;
 }
+export interface CloudflareWorkerServiceBindingConfig {
+    /** Worker binding name exposed on the module worker `env` object. */
+    binding: string;
+    /** Target Cloudflare Worker service name. */
+    service: string;
+    /**
+     * Optional application path prefix that Modern.js should dispatch to this
+     * service binding with `env[binding].fetch(request)`.
+     */
+    prefix?: string;
+}
 export interface CloudflareWorkerSecurityCspConfig {
     mode?: CloudflareWorkerSecurityCspMode;
     directives?: Record<string, string[] | string | false>;

package/dist/types/types/config/deploy.d.ts

@@ -1,5 +1,5 @@
-import type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerSecurityConfig, DeployTarget, JsonValue } from './cloudflareDeploy';
-export type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerSecurityCorsConfig, CloudflareWorkerSecurityCspConfig, CloudflareWorkerSecurityCspMode, CloudflareWorkerSecurityNoindexConfig, DeployTarget, JsonValue, } from './cloudflareDeploy';
+import type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerPublicAssetConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerServiceBindingConfig, DeployTarget, JsonValue } from './cloudflareDeploy';
+export type { CloudflareWorkerArtifactConfig, CloudflareWorkerD1DatabaseConfig, CloudflareWorkerPublicAssetConfig, CloudflareWorkerSecurityConfig, CloudflareWorkerSecurityCorsConfig, CloudflareWorkerSecurityCspConfig, CloudflareWorkerSecurityCspMode, CloudflareWorkerSecurityNoindexConfig, CloudflareWorkerServiceBindingConfig, DeployTarget, JsonValue, } from './cloudflareDeploy';
 export interface MicroFrontend {
     /**
      * Specifies whether to enable the HTML entry.
@@ -47,12 +47,25 @@ export interface DeployUserConfig {
          * Use this for provider resources such as migrations or generated config.
          */
         artifacts?: CloudflareWorkerArtifactConfig[];
+        /**
+         * Additional app-root files or directories to serve as Cloudflare Worker
+         * Static Assets under `.output/public`. Use `to: '.'` to copy a
+         * source directory's contents into the public asset root.
+         */
+        publicAssets?: CloudflareWorkerPublicAssetConfig[];
         /**
          * First-class Cloudflare D1 bindings. Modern.js writes these to
          * `wrangler.json` as `d1_databases` and stages configured migration
          * directories into `.output`.
          */
         d1Databases?: CloudflareWorkerD1DatabaseConfig[];
+        /**
+         * First-class Cloudflare service bindings. Modern.js writes these to
+         * `wrangler.json` as `services`; when a binding also has `prefix`,
+         * the generated Worker dispatches matching requests through
+         * `env[binding].fetch(request)`.
+         */
+        services?: CloudflareWorkerServiceBindingConfig[];
         /**
          * Dist output paths that must not be copied into Cloudflare public assets.
          * Entries are slash-normalized path prefixes relative to the app dist root.

package/lib/types.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="node" />
 /// <reference types="react" />
 /// <reference types="react-dom" />
-/// <reference types="@rsbuild/core/types" />
-/// <reference path="../dist/types/index.d.ts" />
 
 declare namespace NodeJS {
   interface ProcessEnv {
@@ -12,7 +10,8 @@ declare namespace NodeJS {
   }
 }
 
-// reference @rsbuild/core/types, but there are some differences, such as svg
+// Keep this app-environment surface independent from framework configuration
+// declarations so strict app typecheck does not enter toolchain internals.
 /**
  * Image assets
  */