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

package/src/release-envelope/index.ts

@@ -381,8 +381,8 @@ const assertUniqueSortedArtifacts = (
 };
 
 const assertSurfacePaths = (value: unknown, location: string): string[] => {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error(`${location} must contain at least one artifact path.`);
+  if (!Array.isArray(value)) {
+    throw new Error(`${location} must be an array of artifact paths.`);
   }
   const paths = value.map((item, index) =>
     assertNormalizedLogicalPath(item, `${location}[${index}]`),
@@ -413,10 +413,31 @@ const assertSurfaces = (value: unknown): MicroVerticalReleaseSurfaces => {
     ['manifest', 'container'],
     'surfaces.backendFederation',
   );
+  const uiClient = assertSurfacePaths(surfaces.uiClient, 'surfaces.uiClient');
+  const ssr = assertSurfacePaths(surfaces.ssr, 'surfaces.ssr');
+  const apiBackend = assertSurfacePaths(
+    surfaces.apiBackend,
+    'surfaces.apiBackend',
+  );
+  if (uiClient.length > 0 && ssr.length === 0) {
+    throw new Error(
+      'surfaces.ssr must contain at least one artifact path when UI/client is declared.',
+    );
+  }
+  if (ssr.length > 0 && uiClient.length === 0) {
+    throw new Error(
+      'surfaces.uiClient must contain at least one artifact path when SSR is declared.',
+    );
+  }
+  if (apiBackend.length === 0) {
+    throw new Error(
+      'surfaces.apiBackend must contain at least one artifact path.',
+    );
+  }
   return {
-    uiClient: assertSurfacePaths(surfaces.uiClient, 'surfaces.uiClient'),
-    ssr: assertSurfacePaths(surfaces.ssr, 'surfaces.ssr'),
-    apiBackend: assertSurfacePaths(surfaces.apiBackend, 'surfaces.apiBackend'),
+    uiClient,
+    ssr,
+    apiBackend,
     backendFederation: {
       manifest: assertNormalizedLogicalPath(
         backendFederation.manifest,

package/src/release-envelope/plugin.ts

@@ -1,4 +1,14 @@
 import path from 'node:path';
+import type { NodePublicAssetConfig } from '../config';
+import {
+  NODE_PUBLIC_ASSET_SCOPE,
+  normalizeDeclaredPublicAssets,
+  resolveAddedDeclaredPublicAssetPaths,
+} from '../deploy-output/public-assets';
+import {
+  getDeployingTarget,
+  type ResolvedDeployTarget,
+} from '../deploy-output/target';
 import {
   emitFrameworkMicroVerticalReleaseEnvelope,
   emitNodeStagedReleaseEnvelope,
@@ -6,10 +16,8 @@ import {
   verifyNodeReleaseEnvelopeStaging,
 } from './framework-output';
 
-type ReleaseEnvelopeTarget = 'cloudflare' | 'node' | string;
-
 export interface ReleaseEnvelopeConfig {
-  deploy?: { target?: string };
+  deploy?: { node?: { publicAssets?: NodePublicAssetConfig[] } };
 }
 
 export interface ReleaseEnvelopeAppContext {
@@ -17,6 +25,7 @@ export interface ReleaseEnvelopeAppContext {
   appDirectory: string;
   distDirectory: string;
   metaName: string;
+  deployTarget?: ResolvedDeployTarget;
 }
 
 export interface ReleaseEnvelopePluginApi<
@@ -38,60 +47,46 @@ export interface ReleaseEnvelopePlugin<
   setup(api: ReleaseEnvelopePluginApi<Config>): void;
 }
 
-export type ResolveDeployTarget<
-  Config extends ReleaseEnvelopeConfig = ReleaseEnvelopeConfig,
-> = (config: Config) => ReleaseEnvelopeTarget;
-
-const resolveActiveDeployTarget = <Config extends ReleaseEnvelopeConfig>(
-  api: ReleaseEnvelopePluginApi<Config>,
-  resolveDeployTarget: ResolveDeployTarget<Config>,
-) => {
-  const { metaName } = api.getAppContext();
-  const config = api.getNormalizedConfig();
-  if (
-    metaName !== 'modern-js' &&
-    !config.deploy?.target &&
-    !process.env.MODERNJS_DEPLOY
-  ) {
-    return undefined;
-  }
-  return resolveDeployTarget(config);
-};
-
 export const createUltramodernReleaseEnvelopePlugin = <
   Config extends ReleaseEnvelopeConfig,
->({
-  resolveDeployTarget,
-}: {
-  resolveDeployTarget: ResolveDeployTarget<Config>;
-}): ReleaseEnvelopePlugin<Config> => {
+>(): ReleaseEnvelopePlugin<Config> => {
   return {
     name: '@modern-js/ultramodern-release-envelope',
-    pre: ['@modern-js/backend-federation-build', '@modern-js/plugin-bff'],
+    pre: [
+      '@modern-js/backend-federation-build',
+      '@modern-js/plugin-bff',
+      '@modern-js/deploy-output-aliases',
+      '@modern-js/deploy-output-public-assets',
+    ],
     post: ['@modern-js/plugin-deploy'],
     setup(api) {
-      const emitBuildEnvelope = async (target: 'node' | 'cloudflare') => {
+      const emitBuildEnvelope = async (
+        target: 'node' | 'cloudflare',
+        requirePromotable = true,
+      ) => {
         const { apiOnly, distDirectory } = api.getAppContext();
         await emitFrameworkMicroVerticalReleaseEnvelope({
           apiOnly,
           distDirectory,
+          requirePromotable,
           target,
         });
       };
 
       api.onAfterBuild(async () => {
-        const configuredTarget = resolveDeployTarget(api.getNormalizedConfig());
+        const configuredTarget = api.getAppContext().deployTarget?.target;
         if (configuredTarget !== 'node' && configuredTarget !== 'cloudflare') {
           return;
         }
-        await emitBuildEnvelope(configuredTarget);
+        // A plain `modern build` is the development path: a dirty or non-Git
+        // checkout resolves to the `workspace` source revision, which is not
+        // promotable but must still build. Deploy re-emits the envelope and
+        // verifies it, so the release gate keeps its teeth there.
+        await emitBuildEnvelope(configuredTarget, false);
       });
 
       api.onBeforeDeploy(async () => {
-        const configuredTarget = resolveActiveDeployTarget(
-          api,
-          resolveDeployTarget,
-        );
+        const configuredTarget = getDeployingTarget(api.getAppContext());
         if (configuredTarget !== 'node') {
           return;
         }
@@ -101,16 +96,24 @@ export const createUltramodernReleaseEnvelopePlugin = <
       });
 
       api.onAfterDeploy(async () => {
-        const configuredTarget = resolveActiveDeployTarget(
-          api,
-          resolveDeployTarget,
-        );
+        const configuredTarget = getDeployingTarget(api.getAppContext());
         if (configuredTarget !== 'node') {
           return;
         }
         const { appDirectory, distDirectory } = api.getAppContext();
         const outputDirectory = path.join(appDirectory, '.output');
         const releaseEnvelope = await emitNodeStagedReleaseEnvelope({
+          // The Node deploy output is a copy of dist, so a declared file
+          // added output exactly when dist has no file at its path.
+          declaredPublicAssets: await resolveAddedDeclaredPublicAssetPaths({
+            appDirectory,
+            assets: normalizeDeclaredPublicAssets(
+              api.getNormalizedConfig().deploy?.node?.publicAssets,
+              NODE_PUBLIC_ASSET_SCOPE,
+            ),
+            generatedRoot: distDirectory,
+            scope: NODE_PUBLIC_ASSET_SCOPE,
+          }),
           distDirectory,
           outputDirectory,
         });

package/src/release-identity.ts

@@ -10,13 +10,24 @@ export type UltramodernReleaseIdentity = {
   sourceRevision: string;
 };
 
+// Inherited GIT_* variables (git hooks export GIT_DIR and GIT_INDEX_FILE)
+// would make git describe some other repository than `workspaceRoot`.
+const workspaceGitEnv = (): NodeJS.ProcessEnv =>
+  Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([name]) => !name.toUpperCase().startsWith('GIT_'),
+    ),
+  );
+
 const gitOutput = (
   workspaceRoot: string,
   args: string[],
 ): string | undefined => {
   try {
-    return execFileSync('git', ['-C', workspaceRoot, ...args], {
+    return execFileSync('git', args, {
+      cwd: workspaceRoot,
       encoding: 'utf8',
+      env: workspaceGitEnv(),
       stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
   } catch {
@@ -84,7 +95,7 @@ export const resolveUltramodernSourceRevision = (
   const revision = gitOutput(gitRoot, ['rev-parse', 'HEAD']);
   const status = gitOutput(gitRoot, [
     'status',
-    '--porcelain=v1',
+    '--porcelain',
     '--untracked-files=all',
   ]);
   if (!revision || status === undefined || status.length > 0) {

package/src/runtime-package-resolution.ts

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { RsbuildPlugin, Rspack } from '@rsbuild/core';
+
+/**
+ * A generated `runtime-register.js` lives inside the *application*, so every
+ * runtime plugin it imports has to resolve from the application's own
+ * `node_modules`. Packages registered by a CLI plugin are dependencies of that
+ * CLI plugin, not of the application, and under an isolated (pnpm) linker the
+ * application cannot see them — the build fails with `Module not found`.
+ *
+ * Instead of freezing a single resolved file (which would lock one export
+ * condition and break the web/node split), the registering package contributes
+ * the `node_modules` directory that actually hosts the package as a *fallback*
+ * module directory. Bare specifiers keep their normal `exports` resolution, the
+ * application's own copy still wins when it declares the dependency, and both
+ * the workspace source layout and a published pnpm layout work.
+ */
+export const findHostingModuleDirectory = (
+  packageName: string,
+  fromDirectory: string,
+): string | undefined => {
+  let directory = path.resolve(fromDirectory);
+  for (;;) {
+    const candidate = path.join(directory, 'node_modules');
+    if (fs.existsSync(path.join(candidate, packageName))) {
+      return candidate;
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) {
+      return undefined;
+    }
+    directory = parent;
+  }
+};
+
+/**
+ * Collect the fallback module directories for the given packages, starting the
+ * search at the module that registers them.
+ */
+export const collectRuntimePackageModuleDirectories = (
+  packageNames: readonly string[],
+  registrarUrl: string,
+): string[] => {
+  const registrarDirectory = path.dirname(fileURLToPath(registrarUrl));
+  const directories: string[] = [];
+  for (const packageName of packageNames) {
+    const directory = findHostingModuleDirectory(
+      packageName,
+      registrarDirectory,
+    );
+    if (directory && !directories.includes(directory)) {
+      directories.push(directory);
+    }
+  }
+  return directories;
+};
+
+const appendModuleDirectories = (
+  config: Rspack.Configuration,
+  directories: readonly string[],
+) => {
+  if (directories.length === 0) {
+    return;
+  }
+  config.resolve ??= {};
+  const existing = config.resolve.modules ?? ['node_modules'];
+  // Appended, never prepended: the application's own upward `node_modules`
+  // search keeps priority, so a declared dependency still wins.
+  config.resolve.modules = [
+    ...existing,
+    ...directories.filter(directory => !existing.includes(directory)),
+  ];
+};
+
+/**
+ * Rsbuild plugin that adds the given directories as fallback module roots for
+ * every environment (web, node and worker bundles alike).
+ */
+export const createRuntimePackageResolutionPlugin = (
+  directories: readonly string[],
+): RsbuildPlugin => ({
+  name: 'ultramodern:runtime-package-resolution',
+  setup(api) {
+    api.modifyRspackConfig({
+      order: 'post',
+      handler(config) {
+        appendModuleDirectories(config, directories);
+      },
+    });
+    api.onBeforeCreateCompiler({
+      order: 'post',
+      handler({ bundlerConfigs }) {
+        for (const config of bundlerConfigs) {
+          appendModuleDirectories(config, directories);
+        }
+      },
+    });
+  },
+});
+
+/** `true` when the package resolves from the registering module at all. */
+export const canResolveRuntimePackage = (
+  packageName: string,
+  registrarUrl: string,
+): boolean => {
+  try {
+    createRequire(registrarUrl).resolve(packageName);
+    return true;
+  } catch {
+    return false;
+  }
+};

package/src/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;
   }

package/src/templates/cloudflare-entry.004-rendering-css.mjs

@@ -2,9 +2,13 @@ function createNoopMonitors() {
   const noop = () => {};
 
   return {
+    counter: noop,
     debug: noop,
     error: noop,
     info: noop,
+    push: noop,
+    timing: noop,
+    trace: noop,
     warn: noop,
   };
 }
@@ -1134,7 +1138,7 @@ async function withRouteCssLinks(
     seenCssHrefs.add(entry.preloadHref);
     return true;
   });
-  for (const { href, preloadHref } of uniqueCssEntries) {
+  for (const { preloadHref } of uniqueCssEntries) {
     const preloadUrl = new URL(preloadHref);
     const preloadReference =
       preloadUrl.origin === requestOrigin

package/src/templates/cloudflare-entry.005-worker-dispatch.mjs

@@ -52,6 +52,52 @@ async function getRequestHandler(workerModule) {
   );
 }
 
+const ROUTE_DATA_REQUEST_PARAM = '__loader';
+
+// Route data requests (`?__loader=`) are answered by the entry's route data
+// worker, like the Node server's data handler. Without a match the request
+// falls through to page rendering, as it does on Node.
+async function dispatchRouteDataRequest(route, request) {
+  const routeDataWorkerPath = route.routeDataWorker;
+  if (
+    !routeDataWorkerPath ||
+    !new URL(request.url).searchParams.has(ROUTE_DATA_REQUEST_PARAM)
+  ) {
+    return undefined;
+  }
+
+  const routeDataWorkerModule = await loadWorkerModule(routeDataWorkerPath);
+  const handleRouteDataRequest = routeDataWorkerModule
+    ? getRuntimeModule(routeDataWorkerModule).handleRouteDataRequest
+    : undefined;
+
+  if (typeof handleRouteDataRequest !== 'function') {
+    return new Response(
+      `Route data worker bundle has no handleRouteDataRequest export: ${routeDataWorkerPath}`,
+      {
+        status: 500,
+        headers: {
+          'content-type': 'text/plain; charset=utf-8',
+          'x-modern-js-route-data-worker': routeDataWorkerPath,
+        },
+      },
+    );
+  }
+
+  return handleRouteDataRequest({
+    request,
+    serverRoutes: MODERN_WORKER_MANIFEST.routeSpec.routes,
+    context: {
+      loaderContext: new Map(),
+      monitors: createNoopMonitors(),
+      reporter: {
+        reportTiming: () => {},
+      },
+    },
+    onTiming() {},
+  });
+}
+
 async function dispatchRouteWorker(route, request, env, ctx) {
   const workerPath = route.worker;
   if (!workerPath) {
@@ -114,14 +160,46 @@ async function dispatchRouteWorker(route, request, env, ctx) {
   );
 }
 
-function matchesPrefix(pathname, prefix) {
+// Worker Static Assets decode percent-encoded paths, so an encoded spelling
+// of a mounted prefix (`/%70refix/...`, `/prefix%2F...`) would otherwise skip
+// the BFF or service binding that owns the prefix and reach ASSETS directly.
+// Resolve such spellings to the canonical pathname the owner sees; a
+// backslash or undecodable spelling becomes a path the owner rejects.
+function resolvePrefixPathname(pathname, prefix) {
   if (!prefix || prefix === '/') {
-    return true;
+    return pathname;
   }
 
   const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  let candidate = pathname;
+
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    if (candidate === normalized || candidate.startsWith(`${normalized}/`)) {
+      return candidate;
+    }
+    if (candidate.startsWith(`${normalized}\\`)) {
+      return `${normalized}/__invalid_encoded_path__`;
+    }
 
-  return pathname === normalized || pathname.startsWith(`${normalized}/`);
+    let decoded;
+    try {
+      decoded = decodeURIComponent(candidate);
+    } catch {
+      return candidate.toLowerCase().startsWith(normalized.toLowerCase())
+        ? `${normalized}/__invalid_encoded_path__`
+        : null;
+    }
+    if (decoded === candidate) {
+      return null;
+    }
+    candidate = decoded;
+  }
+
+  return null;
+}
+
+function matchesPrefix(pathname, prefix) {
+  return resolvePrefixPathname(pathname, prefix) !== null;
 }
 
 function createRequestForMountedPrefix(request, prefix) {
@@ -131,12 +209,13 @@ function createRequestForMountedPrefix(request, prefix) {
 
   const url = new URL(request.url);
   const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  const matchedPathname = resolvePrefixPathname(url.pathname, normalized);
 
-  if (!matchesPrefix(url.pathname, normalized)) {
+  if (matchedPathname === null) {
     return request;
   }
 
-  const nextPath = url.pathname.slice(normalized.length) || '/';
+  const nextPath = matchedPathname.slice(normalized.length) || '/';
   url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
 
   return new Request(url, request);
@@ -263,12 +342,21 @@ function getEffectBffDispatcher(bff, runtime) {
 async function dispatchBffRequest(request, env) {
   const bff = MODERN_WORKER_MANIFEST.bff;
 
-  if (
-    !bff?.worker ||
-    !matchesPrefix(new URL(request.url).pathname, bff.prefix)
-  ) {
+  const requestUrl = new URL(request.url);
+  const matchedPathname = resolvePrefixPathname(
+    requestUrl.pathname,
+    bff?.prefix,
+  );
+  if (!bff?.worker || matchedPathname === null) {
     return null;
   }
+  const canonicalRequest =
+    matchedPathname === requestUrl.pathname
+      ? request
+      : new Request(
+          Object.assign(requestUrl, { pathname: matchedPathname }),
+          request,
+        );
   if (bff.runtimeFramework !== 'effect') {
     return createEffectBffDispatcherErrorResponse(
       bff,
@@ -301,7 +389,7 @@ async function dispatchBffRequest(request, env) {
       return createEffectBffDispatcherErrorResponse(bff, error);
     }
 
-    return effectDispatcher.dispatch(request, { env });
+    return effectDispatcher.dispatch(canonicalRequest, { env });
   }
 
   const directHandler =

package/src/templates/cloudflare-entry.006-fetch-handler.mjs

@@ -62,11 +62,18 @@ export default {
     }
 
     if (route?.worker) {
-      const renderableRequest = createRenderableRequest(request);
+      // Route data requests keep their method, as on the Node server.
+      const routeDataResponse = await dispatchRouteDataRequest(route, request);
 
       return finalizeResponseForRequest(
         withAppCorsHeaders(
-          await dispatchRouteWorker(route, renderableRequest, env, ctx),
+          routeDataResponse ??
+            (await dispatchRouteWorker(
+              route,
+              createRenderableRequest(request),
+              env,
+              ctx,
+            )),
           request,
         ),
         request,