@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/cjs/renderer-build-identity.js

@@ -0,0 +1,134 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    rendererProfileKey: ()=>rendererProfileKey,
+    resolveRendererBuildIdentities: ()=>resolveRendererBuildIdentities
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
+const external_release_identity_js_namespaceObject = require("./release-identity.js");
+const LOCKFILES = [
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lock',
+    'bun.lockb'
+];
+const processNonce = (0, external_node_crypto_namespaceObject.randomUUID)();
+const sha256 = (value)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(value).digest('hex');
+function rendererProfileKey(profile) {
+    return sha256(JSON.stringify([
+        profile.renderer,
+        profile.protocolVersion,
+        profile.compiler,
+        profile.hydration,
+        profile.router,
+        Object.entries(profile.dependencies ?? {}).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0)
+    ]));
+}
+function lockfileHash(projectRoot) {
+    let directory = external_node_path_default().resolve(projectRoot);
+    for(;;){
+        for (const name of LOCKFILES)try {
+            return sha256(external_node_fs_default().readFileSync(external_node_path_default().join(directory, name)));
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) return '';
+        directory = parent;
+    }
+}
+function resolveRendererBuildIdentities(options) {
+    const profile = {
+        renderer: options.profile.renderer,
+        protocolVersion: options.profile.protocolVersion,
+        compiler: options.profile.compiler,
+        hydration: options.profile.hydration,
+        router: options.profile.router
+    };
+    const validation = (0, backend_federation_contracts_namespaceObject.validateRendererProfile)(profile);
+    if (!validation.ok || options.renderer !== profile.renderer) throw new Error(`Renderer/profile identity mismatch: ${JSON.stringify(validation.errors)}.`);
+    const entries = [
+        ...options.entryNames
+    ].sort();
+    if (0 === entries.length || new Set(entries).size !== entries.length || entries.some((value)=>!value || '__proto__' === value)) throw new Error('Renderer build identity requires unique nonempty entry names.');
+    const routerValidation = (0, backend_federation_contracts_namespaceObject.validateRendererRouterBindings)(options.routerBindings, entries, 'routerBindings', options.routerFrameworks);
+    if (!routerValidation.ok) throw new Error(`Invalid renderer router bindings: ${JSON.stringify(routerValidation.errors)}.`);
+    const projectRoot = external_node_path_default().resolve(options.projectRoot);
+    const appId = options.appId ?? JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(projectRoot, 'package.json'), 'utf8')).name;
+    if ('string' != typeof appId || !appId || appId.trim() !== appId) throw new Error('Renderer application identity requires a delivery artifact appId or a package name.');
+    const profileKey = rendererProfileKey(options.profile);
+    const sourceRevision = (0, external_release_identity_js_namespaceObject.resolveUltramodernSourceRevision)(projectRoot, options.sourceRevision);
+    const buildId = sha256(JSON.stringify([
+        profileKey,
+        lockfileHash(projectRoot),
+        'development' === options.mode || 'workspace' === sourceRevision ? processNonce : sourceRevision
+    ]));
+    const identities = Object.fromEntries(entries.map((entryName)=>[
+            entryName,
+            Object.freeze({
+                renderer: options.renderer,
+                appId,
+                entryName,
+                protocolVersion: 1,
+                buildId
+            })
+        ]));
+    return Object.freeze({
+        identities: Object.freeze(identities),
+        buildId,
+        profileKey,
+        sourceRevision,
+        routerBindings: (0, backend_federation_contracts_namespaceObject.immutableRendererRouterBindings)(options.routerBindings)
+    });
+}
+exports.rendererProfileKey = __webpack_exports__.rendererProfileKey;
+exports.resolveRendererBuildIdentities = __webpack_exports__.resolveRendererBuildIdentities;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rendererProfileKey",
+    "resolveRendererBuildIdentities"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/templates/cloudflare-entry.001-bootstrap-security.mjs

@@ -3,8 +3,12 @@ const MODERN_WORKER_MANIFEST = p_workerManifest;
 export const modernWorkerManifest = MODERN_WORKER_MANIFEST;
 const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
 const workerModulePromises = new Map();
-const effectBffDispatcherPromises = new Map();
-const remoteJsonPromises = new Map();
+// workerd forbids awaiting I/O (a `fetch()` Promise) that was started by a
+// different request's execution context. This worker isolate outlives any
+// single request, so this map may only ever hold settled, plain JSON values
+// — never a live fetch Promise shared across requests. In-flight dedupe is
+// instead scoped per request; see `createRemoteJsonFetchScope`.
+const remoteJsonCache = new Map();
 const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
 const ASSET_CORS_ENABLED = CORS_POLICY.assets !== false;
 const APP_CORS_ALLOWED_ORIGINS = (CORS_POLICY.allowedOrigins || []).map(
@@ -24,9 +28,6 @@ const ASSET_CORS_HEADERS = {
   'access-control-allow-origin': '*',
 };
 
-globalThis.__dirname ??= '/';
-globalThis.__filename ??= '/index.js';
-
 function getAllowedAppCorsOrigin(request) {
   if (APP_CORS_ALLOWED_ORIGINS.length === 0) {
     return null;
@@ -226,7 +227,11 @@ function withCloudflareSecurityHeaders(response, request) {
 }
 
 function createRenderableRequest(request) {
-  if (request.method !== 'HEAD') {
+  if (
+    request.method !== 'HEAD' ||
+    request.headers.get('x-rsc-action') ||
+    request.headers.get('x-rsc-tree')
+  ) {
     return request;
   }
 
@@ -242,6 +247,9 @@ function finalizeResponseForRequest(response, request) {
 
   const headers = new Headers(securedResponse.headers);
   headers.delete('content-length');
+  // A HEAD response sends no body, so release the producer's stream instead of abandoning it:
+  // a stream nobody reads never finishes, and whatever waits for its end never runs.
+  securedResponse.body?.cancel().catch(() => undefined);
 
   return new Response(null, {
     headers,

package/dist/cjs/templates/cloudflare-entry.002-assets-routes.mjs

@@ -20,7 +20,7 @@ function withAssetHeaders(response, request) {
   });
 }
 
-async function createCorsPreflightResponse(request, env) {
+async function createCorsPreflightResponse(request, _env) {
   if (request.method !== 'OPTIONS') {
     return null;
   }
@@ -71,7 +71,15 @@ async function fetchAssetByPath(pathname, request, env) {
   const url = new URL(request.url);
   url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
 
-  return fetchAsset(new Request(url, request), env);
+  return fetchAsset(
+    new Request(url, {
+      method: 'GET',
+      headers: request.headers,
+      redirect: request.redirect,
+      signal: request.signal,
+    }),
+    env,
+  );
 }
 
 async function fetchAssetByPathFollowingRedirects(