react-on-rails-pro-node-renderer 17.0.0-rc.2 → 17.0.0-rc.4

package/lib/worker/vm.js

@@ -53,6 +53,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VMContextNotFoundError = void 0;
 exports.hasVMContextForBundle = hasVMContextForBundle;
 exports.getVMContext = getVMContext;
+exports.hasAnyVMContext = hasAnyVMContext;
 exports.buildExecutionContext = buildExecutionContext;
 exports.resetVM = resetVM;
 exports.removeVM = removeVM;
@@ -72,12 +73,55 @@ const log_js_1 = __importDefault(require("../shared/log.js"));
 const configBuilder_js_1 = require("../shared/configBuilder.js");
 const utils_js_1 = require("../shared/utils.js");
 const errorReporter = __importStar(require("../shared/errorReporter.js"));
+const vmSourceMapSupport_js_1 = require("./vmSourceMapSupport.js");
 const readFileAsync = (0, util_1.promisify)(fs_1.default.readFile);
+// Length of the `Module.wrap` prefix that is prepended to the first line of a
+// wrapped bundle. Needed to correct first-line stack-frame columns before
+// source map lookups.
+const MODULE_WRAP_FIRST_LINE_PREFIX_LENGTH = module_1.default.wrap('\n').indexOf('\n');
 const writeFileAsync = (0, util_1.promisify)(fs_1.default.writeFile);
 // Store contexts by their bundle file paths
 const vmContexts = new Map();
 // Track VM creation promises to handle concurrent buildVM requests
 const vmCreationPromises = new Map();
+// Execution contexts can outlive VM pool entries while a request is still
+// running. Keep source maps for those evicted contexts until the request
+// releases them, then drop both the registration and parsed-map cache.
+const activeSourceMapRequestCounts = new Map();
+const evictedSourceMapRegistrations = new Set();
+function retainSourceMapRegistration(sourceMapRegistration) {
+    activeSourceMapRequestCounts.set(sourceMapRegistration, (activeSourceMapRequestCounts.get(sourceMapRegistration) ?? 0) + 1);
+}
+function releaseSourceMapRegistration(sourceMapRegistration) {
+    const currentCount = activeSourceMapRequestCounts.get(sourceMapRegistration) ?? 0;
+    if (currentCount <= 1) {
+        activeSourceMapRequestCounts.delete(sourceMapRegistration);
+        const wasEvicted = evictedSourceMapRegistrations.delete(sourceMapRegistration);
+        // Eviction deletes the VM first today; keep the guard so future callers do
+        // not unregister a source map for a live pooled VM.
+        let isStillInPool = false;
+        for (const vmContext of vmContexts.values()) {
+            if (vmContext.sourceMapRegistration === sourceMapRegistration) {
+                isStillInPool = true;
+                break;
+            }
+        }
+        if (wasEvicted && !isStillInPool) {
+            (0, vmSourceMapSupport_js_1.unregisterBundleForSourceMaps)(sourceMapRegistration);
+        }
+        return;
+    }
+    activeSourceMapRequestCounts.set(sourceMapRegistration, currentCount - 1);
+}
+function retireSourceMapRegistrationAfterEviction(sourceMapRegistration) {
+    (0, vmSourceMapSupport_js_1.retireMissingSourceMapRetry)(sourceMapRegistration);
+    if ((activeSourceMapRequestCounts.get(sourceMapRegistration) ?? 0) > 0) {
+        evictedSourceMapRegistrations.add(sourceMapRegistration);
+    }
+    else {
+        (0, vmSourceMapSupport_js_1.unregisterBundleForSourceMaps)(sourceMapRegistration);
+    }
+}
 /**
  * Returns all bundle paths that have a VM context
  * @internal Used in tests
@@ -91,12 +135,35 @@ function hasVMContextForBundle(bundlePath) {
 function getVMContext(bundlePath) {
     return vmContexts.get(bundlePath);
 }
+/**
+ * Whether this worker has at least one bundle compiled into a VM context.
+ * Used by the built-in /ready readiness endpoint: a worker with zero loaded
+ * bundles cannot serve render requests until a bundle is uploaded.
+ *
+ * This intentionally stays false while a bundle is still compiling in
+ * vmCreationPromises; /ready flips to 200 only after compilation finishes and
+ * the compiled context is stored in vmContexts.
+ *
+ * Pool eviction can remove older bundle contexts, but readiness remains true as
+ * long as at least one compiled bundle remains in the pool.
+ */
+function hasAnyVMContext() {
+    return vmContexts.size > 0;
+}
 const extendContext = (contextObject, additionalContext) => {
     if (log_js_1.default.level === 'debug') {
         log_js_1.default.debug(`Adding ${Object.keys(additionalContext).join(', ')} to context object.`);
     }
     Object.assign(contextObject, additionalContext);
 };
+const readPrepareStackTraceHook = (context) => {
+    try {
+        return vm_1.default.runInContext('typeof Error === "undefined" ? undefined : Error.prepareStackTrace', context);
+    }
+    catch {
+        return undefined;
+    }
+};
 // Helper function to manage VM pool size
 function manageVMPoolSize() {
     const { maxVMPoolSize } = (0, configBuilder_js_1.getConfig)();
@@ -105,9 +172,11 @@ function manageVMPoolSize() {
     }
     const sortedEntries = Array.from(vmContexts.entries()).sort(([, a], [, b]) => a.lastUsed - b.lastUsed);
     while (sortedEntries.length > maxVMPoolSize) {
-        const oldestPath = sortedEntries.shift()?.[0];
-        if (oldestPath) {
+        const oldestEntry = sortedEntries.shift();
+        if (oldestEntry) {
+            const [oldestPath, oldestContext] = oldestEntry;
             vmContexts.delete(oldestPath);
+            retireSourceMapRegistrationAfterEviction(oldestContext.sourceMapRegistration);
             log_js_1.default.debug(`Removed VM for bundle ${oldestPath} due to pool size limit (max: ${maxVMPoolSize})`);
         }
     }
@@ -139,12 +208,29 @@ async function buildVM(filePath) {
     // than a try/finally inside the IIFE, because an IIFE's finally block can
     // execute synchronously (before `vmCreationPromises.set`) when the code throws
     // before the first `await`, which would leave a stale rejected promise in the map.
+    let sourceMapRegistration;
     const vmCreationPromise = (async () => {
         try {
             const { supportModules, stubTimers, additionalContext } = (0, configBuilder_js_1.getConfig)();
             const additionalContextIsObject = additionalContext !== null && additionalContext.constructor === Object;
             const sharedConsoleHistory = new sharedConsoleHistory_js_1.default();
-            const contextObject = { sharedConsoleHistory };
+            // Request-derived bundle paths are built from validated timestamp path components.
+            // Direct `buildExecutionContext` callers pass trusted internal bundle paths.
+            // codeql[js/path-injection]
+            const bundleContents = await readFileAsync(filePath, 'utf8');
+            const firstLineColumnOffset = additionalContextIsObject || supportModules ? MODULE_WRAP_FIRST_LINE_PREFIX_LENGTH : 0;
+            const preloadedSourceMap = await (0, vmSourceMapSupport_js_1.preloadSourceMapJsonForBundle)(filePath, bundleContents);
+            const currentSourceMapRegistration = (0, vmSourceMapSupport_js_1.registerBundleForSourceMaps)(filePath, firstLineColumnOffset, bundleContents, preloadedSourceMap.sourceMapJson, preloadedSourceMap.retryMissingSourceMap);
+            sourceMapRegistration = currentSourceMapRegistration;
+            // Host callback used by the in-VM `Error.prepareStackTrace` hook (see
+            // vmSourceMapSupport.ts) to remap bundle stack frames to original
+            // TS/JS sources. Only resolves positions for registered bundle paths.
+            const contextObject = {
+                sharedConsoleHistory,
+                [vmSourceMapSupport_js_1.SOURCE_MAP_LOOKUP_ATTEMPT_CONTEXT_KEY]: vmSourceMapSupport_js_1.createSourceMapLookupAttempt,
+                [vmSourceMapSupport_js_1.SOURCE_MAP_RESOLVER_CONTEXT_KEY]: (fileName, lineNumber, columnNumber, lookupAttempt) => (0, vmSourceMapSupport_js_1.resolveOriginalPositionForRegistration)(currentSourceMapRegistration, fileName, lineNumber, columnNumber, lookupAttempt),
+                [vmSourceMapSupport_js_1.SOURCE_MAP_STACK_REMAPPER_CONTEXT_KEY]: (stack) => (0, vmSourceMapSupport_js_1.remapStackTrace)(stack, currentSourceMapRegistration),
+            };
             if (supportModules) {
                 // IMPORTANT: When adding anything to this object, update:
                 // 1. docs/oss/building-features/node-renderer/js-configuration.md
@@ -217,20 +303,29 @@ async function buildVM(filePath) {
                 vm_1.default.runInContext(`function clearImmediate() {}`, context);
                 vm_1.default.runInContext(`function queueMicrotask() {}`, context);
             }
-            // Run bundle code in created context:
-            const bundleContents = await readFileAsync(filePath, 'utf8');
+            // Install lazy source-mapped stack traces for errors created inside the
+            // VM. Must run before the bundle is evaluated so the bundle's own error
+            // handling (e.g. react-on-rails `handleError`) sees remapped stacks.
+            vm_1.default.runInContext(vmSourceMapSupport_js_1.PREPARE_STACK_TRACE_INSTALL_SCRIPT, context);
+            const installedPrepareStackTrace = readPrepareStackTraceHook(context);
             // If node-specific code is provided then it must be wrapped into a module wrapper. The bundle
             // may need the `require` function, which is not available when running in vm unless passed in.
+            // Pass `filename` so stack frames point at the real bundle path (instead of
+            // `evalmachine.<anonymous>`), which also keys lazy source map resolution.
             if (additionalContextIsObject || supportModules) {
-                vm_1.default.runInContext(module_1.default.wrap(bundleContents), context)(exports, require, module, filePath, path_1.default.dirname(filePath));
+                vm_1.default.runInContext(module_1.default.wrap(bundleContents), context, { filename: filePath })(exports, require, module, filePath, path_1.default.dirname(filePath));
             }
             else {
-                vm_1.default.runInContext(bundleContents, context);
+                vm_1.default.runInContext(bundleContents, context, { filename: filePath });
+            }
+            if (readPrepareStackTraceHook(context) !== installedPrepareStackTrace) {
+                log_js_1.default.warn('Bundle replaced Error.prepareStackTrace; source-mapped stack traces are disabled for bundle %s', filePath);
             }
             // Only now, after VM is fully initialized, store the context
             const newVmContext = {
                 context,
                 sharedConsoleHistory,
+                sourceMapRegistration: currentSourceMapRegistration,
                 lastUsed: Date.now(),
             };
             vmContexts.set(filePath, newVmContext);
@@ -247,8 +342,18 @@ async function buildVM(filePath) {
             return newVmContext;
         }
         catch (error) {
+            // Materialize/remap the stack before reporting so failed bundle builds
+            // still include original source locations, then retire the registration:
+            // failed builds never enter the VM pool and cannot be reused.
+            (0, vmSourceMapSupport_js_1.remapErrorStack)(error, sourceMapRegistration);
             log_js_1.default.error({ error }, 'Caught Error when creating context in buildVM');
             errorReporter.error(error);
+            if (sourceMapRegistration) {
+                (0, vmSourceMapSupport_js_1.unregisterBundleForSourceMaps)(sourceMapRegistration);
+            }
+            else {
+                (0, vmSourceMapSupport_js_1.unregisterBundleForSourceMaps)(filePath);
+            }
             throw error;
         }
     })();
@@ -305,23 +410,53 @@ async function getOrBuildVMContext(bundleFilePath, buildVmsIfNeeded) {
  * @see handleIncrementalRenderRequest.ts for how update chunks access the same context
  */
 async function buildExecutionContext(bundlePaths, buildVmsIfNeeded) {
+    const retainedSourceMapRegistrations = new Set();
+    const retainSourceMapRegistrationOnce = (sourceMapRegistration) => {
+        if (retainedSourceMapRegistrations.has(sourceMapRegistration)) {
+            return;
+        }
+        retainSourceMapRegistration(sourceMapRegistration);
+        retainedSourceMapRegistrations.add(sourceMapRegistration);
+    };
     const mapBundleFilePathToVMContext = new Map();
-    await Promise.all(bundlePaths.map(async (bundleFilePath) => {
-        const vmContext = await getOrBuildVMContext(bundleFilePath, buildVmsIfNeeded);
-        vmContext.lastUsed = Date.now();
-        mapBundleFilePathToVMContext.set(bundleFilePath, vmContext);
+    let buildRejected = false;
+    let firstBuildRejection;
+    // Wait for every parallel build callback before releasing retained source-map
+    // registrations; otherwise a sibling build can retain after an early rejection.
+    await Promise.allSettled(bundlePaths.map(async (bundleFilePath) => {
+        try {
+            const vmContext = await getOrBuildVMContext(bundleFilePath, buildVmsIfNeeded);
+            retainSourceMapRegistrationOnce(vmContext.sourceMapRegistration);
+            vmContext.lastUsed = Date.now();
+            mapBundleFilePathToVMContext.set(bundleFilePath, vmContext);
+        }
+        catch (error) {
+            if (!buildRejected) {
+                buildRejected = true;
+                firstBuildRejection = error;
+            }
+            throw error;
+        }
     }));
+    if (buildRejected) {
+        retainedSourceMapRegistrations.forEach(releaseSourceMapRegistration);
+        throw firstBuildRejection;
+    }
     // This Map persists for the lifetime of this ExecutionContext (one HTTP request).
     // It allows data to be shared between the initial render and subsequent update chunks.
     // Example: asyncPropsManager is stored here during initial render and accessed by update chunks.
     const sharedExecutionContext = new Map();
+    let released = false;
     const runInVM = async (renderingRequest, bundleFilePath, vmCluster) => {
+        let sourceMapRegistrationForRequest;
         try {
             const { serverBundleCachePath } = (0, configBuilder_js_1.getConfig)();
             const vmContext = mapBundleFilePathToVMContext.get(bundleFilePath);
             if (!vmContext) {
                 throw new VMContextNotFoundError(bundleFilePath);
             }
+            sourceMapRegistrationForRequest = vmContext.sourceMapRegistration;
+            const remapStackTraceForRequest = (stack) => (0, vmSourceMapSupport_js_1.remapStackTrace)(stack, vmContext.sourceMapRegistration);
             // Update last used timestamp
             vmContext.lastUsed = Date.now();
             const { context, sharedConsoleHistory } = vmContext;
@@ -361,7 +496,7 @@ async function buildExecutionContext(bundlePaths, buildVmsIfNeeded) {
             });
             if ((0, utils_js_1.isReadableStream)(result)) {
                 const newStreamAfterHandlingError = (0, utils_js_1.handleStreamError)(result, (error) => {
-                    const msg = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, error, 'Error in a rendering stream');
+                    const msg = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, error, 'Error in a rendering stream', remapStackTraceForRequest);
                     errorReporter.message(msg);
                 });
                 return newStreamAfterHandlingError;
@@ -382,7 +517,9 @@ async function buildExecutionContext(bundlePaths, buildVmsIfNeeded) {
             return result;
         }
         catch (exception) {
-            const exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, exception);
+            const exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, exception, undefined, sourceMapRegistrationForRequest
+                ? (stack) => (0, vmSourceMapSupport_js_1.remapStackTrace)(stack, sourceMapRegistrationForRequest)
+                : (_stack) => undefined);
             log_js_1.default.debug('Caught exception in rendering request: %s', exceptionMessage);
             return Promise.resolve({ exceptionMessage });
         }
@@ -390,19 +527,36 @@ async function buildExecutionContext(bundlePaths, buildVmsIfNeeded) {
     return {
         getVMContext: (bundleFilePath) => mapBundleFilePathToVMContext.get(bundleFilePath),
         runInVM,
+        release: () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            retainedSourceMapRegistrations.forEach(releaseSourceMapRegistration);
+        },
     };
 }
 /** @internal Used in tests */
 function resetVM() {
     vmContexts.clear();
     vmCreationPromises.clear();
+    activeSourceMapRequestCounts.clear();
+    evictedSourceMapRegistrations.clear();
+    (0, vmSourceMapSupport_js_1.resetSourceMapSupport)();
 }
 // Optional: Add a method to remove a specific VM if needed
 /**
  * @public TODO: Remove the line below when this function is actually used
  */
 function removeVM(bundlePath) {
+    const vmContext = vmContexts.get(bundlePath);
     vmContexts.delete(bundlePath);
     vmCreationPromises.delete(bundlePath);
+    if (vmContext) {
+        retireSourceMapRegistrationAfterEviction(vmContext.sourceMapRegistration);
+    }
+    else {
+        (0, vmSourceMapSupport_js_1.unregisterBundleForSourceMaps)(bundlePath);
+    }
 }
 //# sourceMappingURL=vm.js.map

package/lib/worker/vmSourceMapSupport.d.ts

@@ -0,0 +1,110 @@
+export interface BundleSourceMapRegistration {
+    bundleFilePath: string;
+    /**
+     * Column correction for frames on line 1 of the bundle. When the bundle is
+     * evaluated wrapped in `Module.wrap` (the `supportModules` /
+     * `additionalContext` path), the wrapper prefix shifts every first-line
+     * column by its length.
+     */
+    firstLineColumnOffset: number;
+    /**
+     * `undefined` means the bundle text was not available at registration time
+     * and must be checked lazily. `null` means it was checked and no
+     * sourceMappingURL comment was present.
+     */
+    sourceMappingUrl?: string | null;
+    /**
+     * `undefined` keeps lazy synchronous lookup behavior. `null` means registration
+     * time lookup found no usable source map. A string freezes the source-map JSON
+     * for this VM generation so same-path rebuilds cannot remap old bytecode with
+     * a newer map.
+     */
+    sourceMapJson?: string | null;
+    realBundleDirectory: string;
+    /**
+     * External source maps can arrive after a bundle first becomes visible. When
+     * true, a missing external map is retried briefly before caching the miss.
+     */
+    retryMissingSourceMap?: boolean;
+}
+interface SourceMapLookupAttempt {
+    missingSourceMaps: WeakSet<BundleSourceMapRegistration>;
+}
+export declare function retireMissingSourceMapRetry(registration: BundleSourceMapRegistration): void;
+export declare function createSourceMapLookupAttempt(): SourceMapLookupAttempt;
+/**
+ * Name of the host-callback global injected into the VM context. Used by
+ * {@link PREPARE_STACK_TRACE_INSTALL_SCRIPT}.
+ */
+export declare const SOURCE_MAP_RESOLVER_CONTEXT_KEY = "__reactOnRailsProResolveOriginalSourcePosition";
+/**
+ * Name of the host-callback global used to group resolver calls that belong to
+ * one `.stack` formatting attempt.
+ */
+export declare const SOURCE_MAP_LOOKUP_ATTEMPT_CONTEXT_KEY = "__reactOnRailsProCreateSourceMapLookupAttempt";
+/**
+ * Name of the host-callback global injected into the VM context for stacks
+ * serialized by react-on-rails before they can escape to the host formatter.
+ */
+export declare const SOURCE_MAP_STACK_REMAPPER_CONTEXT_KEY = "__reactOnRailsProRemapStackTrace";
+/** @internal Used by VM build to avoid synchronous external-map reads. */
+export declare function preloadSourceMapJsonForBundle(bundleFilePath: string, bundleContents: string): Promise<{
+    retryMissingSourceMap: boolean;
+    sourceMapJson: string | null;
+} | {
+    retryMissingSourceMap: boolean;
+    sourceMapJson: string | undefined;
+}>;
+/**
+ * Registers a bundle file so stack frames pointing into it can be remapped.
+ * Pass `bundleContents` when available; omitting it makes the first error-path
+ * lookup synchronously re-read the bundle to find its `sourceMappingURL`.
+ * `preloadedSourceMapJson` supplies known JSON/null for this VM generation;
+ * `retryMissingSourceMap` keeps external preload misses retryable until a map is
+ * found, the retry cap is reached, or a same-path generation replaces the registration.
+ */
+export declare function registerBundleForSourceMaps(bundleFilePath: string, firstLineColumnOffset?: number, bundleContents?: string, preloadedSourceMapJson?: string | null, retryMissingSourceMap?: boolean): {
+    bundleFilePath: string;
+    firstLineColumnOffset: number;
+    realBundleDirectory: string;
+    sourceMappingUrl: string | null | undefined;
+    sourceMapJson: string | null | undefined;
+    retryMissingSourceMap: boolean;
+};
+/**
+ * Drops the registration and any cached source map for a bundle.
+ */
+export declare function unregisterBundleForSourceMaps(bundleOrRegistration: string | BundleSourceMapRegistration): void;
+/** @internal Used in tests */
+export declare function resetSourceMapSupport(): void;
+export interface ResolvedSourcePosition {
+    source: string;
+    line: number;
+    column: number;
+}
+/**
+ * Resolves a 1-based generated position in a registered bundle to its original
+ * source position. Returns null when the position cannot be mapped.
+ *
+ * SECURITY: this function is exposed to untrusted bundle code inside the VM
+ * context, so it validates its inputs and only operates on registered bundle
+ * paths.
+ *
+ * @param lineNumber 1-based generated line number, matching V8 CallSite values.
+ * @param columnNumber 1-based generated column number, matching V8 CallSite values.
+ */
+export declare function resolveOriginalPositionForRegistration(registration: BundleSourceMapRegistration, fileName: unknown, lineNumber: unknown, columnNumber: unknown, lookupAttempt?: unknown): ResolvedSourcePosition | null;
+export declare function remapStackTrace(stack: unknown, registration?: BundleSourceMapRegistration): string | undefined;
+export declare function remapErrorStack(error: unknown, registration?: BundleSourceMapRegistration): void;
+/**
+ * Script run inside the VM context (before the bundle is evaluated) that
+ * installs an `Error.prepareStackTrace` mirroring V8's default format but
+ * rewriting `file:line:column` locations through the host-side resolver when a
+ * source-mapped position is available. Bundle code can replace
+ * `Error.prepareStackTrace` after this script runs; if it does, source mapping
+ * is disabled for that VM context. Any failure falls back to the original frame
+ * text.
+ */
+export declare const PREPARE_STACK_TRACE_INSTALL_SCRIPT = "\nError.prepareStackTrace = function (error, callSites) {\n  var header;\n  try {\n    header = String(error);\n  } catch (formatError) {\n    header = '<error>';\n  }\n  var parts = [header];\n  var sourceMapLookupAttempt;\n  try {\n    if (typeof __reactOnRailsProCreateSourceMapLookupAttempt === 'function') {\n      sourceMapLookupAttempt = __reactOnRailsProCreateSourceMapLookupAttempt();\n    }\n  } catch (lookupAttemptError) {\n    sourceMapLookupAttempt = undefined;\n  }\n  for (var i = 0; i < callSites.length; i++) {\n    var frameText;\n    try {\n      frameText = String(callSites[i]);\n    } catch (formatFrameError) {\n      frameText = '<frame>';\n    }\n    try {\n      var fileName = callSites[i].getFileName();\n      var line = callSites[i].getLineNumber();\n      var column = callSites[i].getColumnNumber();\n      if (\n        fileName != null &&\n        line != null &&\n        column != null &&\n        typeof __reactOnRailsProResolveOriginalSourcePosition === 'function'\n      ) {\n        var position = __reactOnRailsProResolveOriginalSourcePosition(fileName, line, column, sourceMapLookupAttempt);\n        if (position) {\n          var generatedLocation = fileName + ':' + line + ':' + column;\n          var originalLocation = position.source + ':' + position.line + ':' + position.column;\n          if (frameText.indexOf(generatedLocation) !== -1) {\n            // String first-arg: replace only the frame's canonical location once.\n            // Do not use a /g regex here; a repeated numeric location elsewhere\n            // in the frame text should not be rewritten.\n            frameText = frameText.replace(generatedLocation, function () { return originalLocation; });\n          } else {\n            frameText = frameText + ' -> ' + originalLocation;\n          }\n        }\n      }\n    } catch (resolveError) {\n      // Keep the original frame text.\n    }\n    parts.push('    at ' + frameText);\n  }\n  return parts.join('\\n');\n};\n";
+export {};
+//# sourceMappingURL=vmSourceMapSupport.d.ts.map