react-on-rails-pro-node-renderer 17.0.0-rc.5 → 17.0.0-rc.7

package/lib/integrations/opentelemetry.js

@@ -17,10 +17,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const api_js_1 = require("./api.js");
 const DEFAULT_SERVICE_NAME = 'react-on-rails-pro-node-renderer';
-const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5_000;
 // Leave 1s of headroom under the worker's hard cap so the shutdown hook can
 // resolve cleanly even when provider.shutdown() runs right at its limit.
-const MAX_SHUTDOWN_TIMEOUT_MS = api_js_1.WORKER_SHUTDOWN_HOOKS_TIMEOUT_MS - 1000;
+const MAX_SHUTDOWN_TIMEOUT_MS = api_js_1.WORKER_SHUTDOWN_HOOKS_TIMEOUT_MS - 1_000;
 function isProduction() {
     return process.env.NODE_ENV === 'production' || process.env.RAILS_ENV === 'production';
 }
@@ -265,7 +265,7 @@ function init(opts = {}) {
         }
         let shutdownOpenTelemetryPromise;
         const shutdownOpenTelemetry = () => {
-            shutdownOpenTelemetryPromise ?? (shutdownOpenTelemetryPromise = (async () => {
+            shutdownOpenTelemetryPromise ??= (async () => {
                 try {
                     await shutdownProviderWithTimeout(provider, shutdownTimeoutMs);
                     if ((0, api_js_1.getOpenTelemetryTracerProvider)() === provider) {
@@ -279,7 +279,7 @@ function init(opts = {}) {
                     unregisterFastifyConfig?.();
                     unregisterWorkerShutdownHook?.();
                 }
-            })());
+            })();
             return shutdownOpenTelemetryPromise;
         };
         // Register these last so failed init paths do not leave partial shutdown hooks

package/lib/master/restartWorkers.js

@@ -25,39 +25,93 @@ exports.default = restartWorkers;
 const cluster_1 = __importDefault(require("cluster"));
 const log_js_1 = __importDefault(require("../shared/log.js"));
 const utils_js_1 = require("../shared/utils.js");
+const MILLISECONDS_IN_SECOND = 1000;
 const MILLISECONDS_IN_MINUTE = 60000;
+function currentWorker(workerId) {
+    const worker = cluster_1.default.workers?.[workerId];
+    if (!worker) {
+        log_js_1.default.debug('Worker #%s is no longer available for scheduled restart', workerId);
+        return undefined;
+    }
+    if (worker.isDead()) {
+        log_js_1.default.debug('Worker #%d is already dead before scheduled restart', worker.id);
+        return undefined;
+    }
+    return worker;
+}
 async function restartWorkers(delayBetweenIndividualWorkerRestarts, gracefulWorkerRestartTimeout) {
     log_js_1.default.info('Started scheduled restart of workers');
-    if (!cluster_1.default.workers) {
-        throw new Error('No workers to restart');
+    const workerIds = Object.keys(cluster_1.default.workers ?? {});
+    if (workerIds.length === 0) {
+        log_js_1.default.warn('No workers to restart');
+        return;
     }
-    for (const worker of Object.values(cluster_1.default.workers).filter((w) => !!w)) {
-        log_js_1.default.debug('Kill worker #%d', worker.id);
-        worker.isScheduledRestart = true;
-        worker.send(utils_js_1.SHUTDOWN_WORKER_MESSAGE);
-        // It's inteded to restart worker in sequence, it shouldn't happens in parallel
-        // eslint-disable-next-line no-await-in-loop
-        await new Promise((resolve) => {
-            let timeout;
-            const onExit = () => {
-                clearTimeout(timeout);
-                resolve();
-            };
-            worker.on('exit', onExit);
-            // Zero means no timeout
-            if (gracefulWorkerRestartTimeout) {
-                timeout = setTimeout(() => {
-                    log_js_1.default.debug('Worker #%d timed out, forcing kill it', worker.id);
-                    worker.destroy();
-                    worker.off('exit', onExit);
+    for (const workerId of workerIds) {
+        const worker = currentWorker(workerId);
+        if (worker) {
+            const workerToRestart = worker;
+            log_js_1.default.debug('Kill worker #%d', workerToRestart.id);
+            workerToRestart.isScheduledRestart = true;
+            // It's intended to restart worker in sequence, it shouldn't happen in parallel
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve) => {
+                let timeout;
+                let isResolved = false;
+                let finish = () => { };
+                const onExit = () => {
+                    finish();
+                };
+                const onError = (err) => {
+                    log_js_1.default.warn({ msg: 'Error while waiting for scheduled worker restart', err });
+                    if (!gracefulWorkerRestartTimeout) {
+                        workerToRestart.isScheduledRestart = false;
+                        finish();
+                    }
+                };
+                const onSendError = (err) => {
+                    if (!err || isResolved)
+                        return;
+                    workerToRestart.isScheduledRestart = false;
+                    log_js_1.default.warn({ msg: 'Error sending scheduled graceful shutdown message to worker', err });
+                    finish();
+                };
+                finish = () => {
+                    if (isResolved)
+                        return;
+                    isResolved = true;
+                    if (timeout)
+                        clearTimeout(timeout);
+                    workerToRestart.off('exit', onExit);
+                    workerToRestart.off('error', onError);
                     resolve();
-                }, gracefulWorkerRestartTimeout);
-            }
-        });
-        // eslint-disable-next-line no-await-in-loop
-        await new Promise((resolve) => {
-            setTimeout(resolve, delayBetweenIndividualWorkerRestarts * MILLISECONDS_IN_MINUTE);
-        });
+                };
+                workerToRestart.on('exit', onExit);
+                workerToRestart.on('error', onError);
+                try {
+                    workerToRestart.send(utils_js_1.SHUTDOWN_WORKER_MESSAGE, onSendError);
+                }
+                catch (err) {
+                    workerToRestart.isScheduledRestart = false;
+                    log_js_1.default.warn({ msg: 'Error sending scheduled graceful shutdown message to worker', err });
+                    finish();
+                    return;
+                }
+                if (isResolved)
+                    return;
+                // Zero means no timeout
+                if (gracefulWorkerRestartTimeout) {
+                    timeout = setTimeout(() => {
+                        log_js_1.default.debug('Worker #%d timed out, forcing kill it', workerToRestart.id);
+                        workerToRestart.destroy();
+                        finish();
+                    }, gracefulWorkerRestartTimeout * MILLISECONDS_IN_SECOND);
+                }
+            });
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve) => {
+                setTimeout(resolve, delayBetweenIndividualWorkerRestarts * MILLISECONDS_IN_MINUTE);
+            });
+        }
     }
     log_js_1.default.info('Finished scheduled restart of workers');
 }

package/lib/master.js

@@ -148,6 +148,7 @@ function masterRun(runningConfig) {
     let isAbortingForStartupFailure = false;
     let hasReportedStartupFailure = false;
     let fatalStartupFailure = null;
+    const gracefulShutdownAcknowledgedWorkerIds = new Set();
     // Set as soon as any shutdown path (external signal or startup-failure abort)
     // begins. Read by the `cluster.on('exit')` handler to suppress re-forking
     // workers that exit because we are intentionally tearing the cluster down.
@@ -163,13 +164,15 @@ function masterRun(runningConfig) {
     // exits. A hard-deadline timer guarantees the master still exits if a worker
     // is stuck.
     const currentWorkers = () => Object.values(cluster_1.default.workers ?? {}).filter((worker) => Boolean(worker));
-    const forceKillSurvivingWorkers = (workers) => {
+    const forceKillSurvivingWorkers = (workers, { skipAcknowledgedWorkers = false } = {}) => {
         workers.forEach((worker) => {
             const workerProcess = worker.process;
             // isDead() only: ChildProcess.killed means a signal was sent, not that
             // the process died — e.g. a blocked worker surviving destroy()'s SIGTERM.
             if (worker.isDead())
                 return;
+            if (skipAcknowledgedWorkers && gracefulShutdownAcknowledgedWorkerIds.has(worker.id))
+                return;
             try {
                 workerProcess.kill('SIGKILL');
             }
@@ -227,8 +230,13 @@ function masterRun(runningConfig) {
         // Early force-kill of workers that cannot drain (blocked event loop).
         // Their SIGKILL-induced exits complete the disconnect, which lets the
         // normal waitForWorkerExits path below finish the shutdown promptly.
+        // ACK means the worker accepted shutdown and disconnected itself from new
+        // requests; it may still be draining an active render. Keep ACKed workers
+        // alive until the hard deadline so graceful drain can finish. Deployments
+        // with shorter supervisor grace windows can still terminate the master
+        // before that hard deadline and should tune the supervisor window.
         const forceKillTimer = setTimeout(() => {
-            forceKillSurvivingWorkers(workersAtShutdown);
+            forceKillSurvivingWorkers(workersAtShutdown, { skipAcknowledgedWorkers: true });
         }, SHUTDOWN_WORKER_FORCE_KILL_TIMEOUT_MS);
         if (typeof forceKillTimer.unref === 'function')
             forceKillTimer.unref();
@@ -274,6 +282,10 @@ function masterRun(runningConfig) {
         return true;
     };
     cluster_1.default.on('message', (worker, message) => {
+        if (message === utils_js_1.SHUTDOWN_WORKER_ACK_MESSAGE) {
+            gracefulShutdownAcknowledgedWorkerIds.add(worker.id);
+            return;
+        }
         // Check the abort flag first to short-circuit the type-guard on every
         // ordinary IPC message once we are already aborting.
         if (isAbortingForStartupFailure || !(0, workerMessages_js_1.isWorkerStartupFailureMessage)(message))
@@ -283,6 +295,7 @@ function masterRun(runningConfig) {
     });
     // Listen for dying workers:
     cluster_1.default.on('exit', (worker) => {
+        gracefulShutdownAcknowledgedWorkerIds.delete(worker.id);
         // Once a startup failure has been detected, abort regardless of whether
         // this particular exit was from the failing worker, a scheduled restart,
         // or an unrelated crash. Don't fork any more workers. If an external signal
@@ -336,7 +349,11 @@ function masterRun(runningConfig) {
         log_js_1.default.info('Scheduled workers restarts every %d minutes (%d minutes btw each)', allWorkersRestartInterval, delayBetweenIndividualWorkerRestarts);
         const allWorkersRestartIntervalMS = allWorkersRestartInterval * MILLISECONDS_IN_MINUTE;
         const scheduleWorkersRestart = () => {
-            void (0, restartWorkers_js_1.default)(delayBetweenIndividualWorkerRestarts, gracefulWorkerRestartTimeout).finally(() => {
+            void (0, restartWorkers_js_1.default)(delayBetweenIndividualWorkerRestarts, gracefulWorkerRestartTimeout)
+                .catch((err) => {
+                log_js_1.default.error({ msg: 'Scheduled worker restart failed', err });
+            })
+                .finally(() => {
                 setTimeout(scheduleWorkersRestart, allWorkersRestartIntervalMS);
             });
         };

package/lib/shared/checkRscPeerCompatibility.d.ts

@@ -1,9 +1,8 @@
-export type RscPeerCheckLevel = 'ok' | 'warn' | 'error';
 export type RscPeerCheckResult = {
     level: 'ok';
     message?: undefined;
 } | {
-    level: Exclude<RscPeerCheckLevel, 'ok'>;
+    level: 'error';
     message: string;
 };
 export interface RscPeerCheckInput {

package/lib/shared/checkRscPeerCompatibility.js

@@ -16,35 +16,83 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkRscPeerCompatibility = checkRscPeerCompatibility;
 const rscPeerSupport_js_1 = require("./rscPeerSupport.js");
-// Strip build metadata (`+...`) and prerelease (`-...`) so a coordinated RC such as
-// `19.0.5-rc.7` compares as `19.0.5`. We only need major/minor/patch ordering, so this
-// avoids semver's prerelease rules (and a `semver` dependency) entirely.
-const parseTuple = (version) => {
+const parseVersion = (version) => {
     // `resolveVersion` is a public injection point, so tolerate a leading `v`/`=` (e.g. `v19.0.4`).
     // Malformed versions intentionally coerce to 0 segments so the major mismatch
     // branch reports the original string instead of hiding it behind a parse error.
     const normalized = version.replace(/^[v=]+/, '');
-    const [withoutBuild = ''] = normalized.split('+', 1);
-    const [core = ''] = withoutBuild.split('-', 1);
+    const buildIndex = normalized.indexOf('+');
+    const withoutBuild = buildIndex === -1 ? normalized : normalized.slice(0, buildIndex);
+    const prereleaseIndex = withoutBuild.indexOf('-');
+    const core = prereleaseIndex === -1 ? withoutBuild : withoutBuild.slice(0, prereleaseIndex);
+    const prerelease = prereleaseIndex === -1 ? null : withoutBuild.slice(prereleaseIndex + 1) || null;
     const parts = core.split('.');
-    return [Number(parts[0]) || 0, Number(parts[1]) || 0, Number(parts[2]) || 0];
+    return {
+        tuple: [Number(parts[0]) || 0, Number(parts[1]) || 0, Number(parts[2]) || 0],
+        prerelease: prerelease || null,
+    };
 };
-const isAtLeast = (actual, floor) => {
+const parseTuple = (version) => parseVersion(version).tuple;
+const comparePrereleasePart = (left, right) => {
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric)
+        return Number(left) - Number(right);
+    if (leftNumeric)
+        return -1;
+    if (rightNumeric)
+        return 1;
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+const comparePrerelease = (left, right) => {
+    if (left === right)
+        return 0;
+    if (!left)
+        return 1;
+    if (!right)
+        return -1;
+    const leftParts = left.split('.');
+    const rightParts = right.split('.');
+    const maxParts = Math.max(leftParts.length, rightParts.length);
+    for (let i = 0; i < maxParts; i += 1) {
+        const leftPart = leftParts[i];
+        const rightPart = rightParts[i];
+        if (leftPart === undefined)
+            return -1;
+        if (rightPart === undefined)
+            return 1;
+        const comparison = comparePrereleasePart(leftPart, rightPart);
+        if (comparison !== 0)
+            return comparison;
+    }
+    return 0;
+};
+const compareVersions = (actual, floor) => {
+    const actualVersion = parseVersion(actual);
+    const floorVersion = parseVersion(floor);
     for (let i = 0; i < 3; i += 1) {
-        const a = actual[i] ?? 0;
-        const f = floor[i] ?? 0;
+        const a = actualVersion.tuple[i] ?? 0;
+        const f = floorVersion.tuple[i] ?? 0;
         if (a > f)
-            return true;
+            return 1;
         if (a < f)
-            return false;
+            return -1;
     }
-    return true;
+    return comparePrerelease(actualVersion.prerelease, floorVersion.prerelease);
 };
+const isAtLeastVersion = (actual, floor) => compareVersions(actual, floor) >= 0;
 const sameTuple = (left, right) => left.every((value, index) => value === right[index]);
 const supportedRscRange = ({ supportedMajor }, { supportedRanges }) => {
     const supportedMinors = [...new Set(supportedRanges.map((range) => range.rscMinor))].sort((left, right) => left - right);
     return supportedMinors.map((minor) => `${supportedMajor}.${minor}.x`).join(' or ');
 };
+const rscFloorRange = ({ minimumVersion, minimumPrereleaseVersion, }) => minimumPrereleaseVersion
+    ? `>= ${minimumVersion} (or ${minimumPrereleaseVersion} during the RC soak)`
+    : `>= ${minimumVersion}`;
 const supportedReactRange = (rscTuple, { supportedMajor, supportedRanges }) => {
     const rscMinor = rscTuple[1];
     const matchingRanges = supportedRanges.filter((range) => range.rscMinor === rscMinor);
@@ -62,11 +110,6 @@ const errorMessage = (pkg, found, want, proVersion) => [
     `  Upgrade or downgrade ${pkg} to a compatible release. See https://www.shakacode.com/react-on-rails-pro/docs/.`,
     `  (Set REACT_ON_RAILS_PRO_DISABLE_VERSION_CHECK=1 to downgrade this error to a warning.)`,
 ].join('\n');
-const warnMessage = (found, recommendedMin, proVersion) => [
-    `[ReactOnRails] react-on-rails-rsc ${found} is older than the recommended minimum ${recommendedMin}.`,
-    `  ${proLabel(proVersion)} may behave incorrectly (missing coordinated RSC fixes).`,
-    `  Upgrade react-on-rails-rsc to ${recommendedMin} or newer.`,
-].join('\n');
 function checkRscPeerCompatibility(input) {
     const { rscVersion, reactVersion, reactDomVersion, proVersion } = input;
     // react-on-rails-rsc is an optional peer. Absent => the consumer is not on the RSC
@@ -74,7 +117,8 @@ function checkRscPeerCompatibility(input) {
     if (!rscVersion)
         return { level: 'ok' };
     const { reactOnRailsRsc, react } = rscPeerSupport_js_1.RSC_PEER_SUPPORT;
-    const rscTuple = parseTuple(rscVersion);
+    const rscParsedVersion = parseVersion(rscVersion);
+    const rscTuple = rscParsedVersion.tuple;
     const [rscMajor] = rscTuple;
     if (rscMajor !== reactOnRailsRsc.supportedMajor) {
         return {
@@ -82,6 +126,20 @@ function checkRscPeerCompatibility(input) {
             message: errorMessage('react-on-rails-rsc', rscVersion, `${reactOnRailsRsc.supportedMajor}.x`, proVersion),
         };
     }
+    const meetsStableFloor = !rscParsedVersion.prerelease && isAtLeastVersion(rscVersion, reactOnRailsRsc.minimumVersion);
+    const minimumPrereleaseTuple = reactOnRailsRsc.minimumPrereleaseVersion
+        ? parseTuple(reactOnRailsRsc.minimumPrereleaseVersion)
+        : null;
+    const meetsPrereleaseFloor = reactOnRailsRsc.minimumPrereleaseVersion &&
+        minimumPrereleaseTuple &&
+        sameTuple(rscTuple, minimumPrereleaseTuple) &&
+        isAtLeastVersion(rscVersion, reactOnRailsRsc.minimumPrereleaseVersion);
+    if (!meetsStableFloor && !meetsPrereleaseFloor) {
+        return {
+            level: 'error',
+            message: errorMessage('react-on-rails-rsc', rscVersion, rscFloorRange(reactOnRailsRsc), proVersion),
+        };
+    }
     if (!isSupportedRscMinor(rscTuple, react)) {
         return {
             level: 'error',
@@ -115,9 +173,6 @@ function checkRscPeerCompatibility(input) {
             };
         }
     }
-    if (!isAtLeast(rscTuple, parseTuple(reactOnRailsRsc.recommendedMin))) {
-        return { level: 'warn', message: warnMessage(rscVersion, reactOnRailsRsc.recommendedMin, proVersion) };
-    }
     return { level: 'ok' };
 }
 //# sourceMappingURL=checkRscPeerCompatibility.js.map

package/lib/shared/configBuilder.js

@@ -92,13 +92,20 @@ function normalizedRuntimeEnvs() {
         .filter((value) => Boolean(value))
         .map((value) => value.toLowerCase());
 }
-function runtimeEnvsAllowDevelopmentDefaults() {
-    const runtimeEnvs = normalizedRuntimeEnvs();
+function runtimeEnvsAllowDevelopmentDefaults(runtimeEnvs = normalizedRuntimeEnvs()) {
     // Fail closed: every present runtime env must be development/test before we allow
     // missing-password defaults. Any production-like value, or no env at all, still
     // requires an explicit password.
     return runtimeEnvs.length > 0 && runtimeEnvs.every((value) => value === 'development' || value === 'test');
 }
+function unsetRuntimeEnvPasswordGuidance(runtimeEnvs) {
+    if (runtimeEnvs.length > 0) {
+        return '';
+    }
+    return ('\n\nBoth RAILS_ENV and NODE_ENV are unset. For a local Rails development shell, either set them explicitly:\n\n' +
+        '  export RAILS_ENV=development NODE_ENV=development\n\n' +
+        'or configure RENDERER_PASSWORD. Deployed/shared environments should set explicit envs and RENDERER_PASSWORD.');
+}
 // Intentionally checks only NODE_ENV, not both NODE_ENV and RAILS_ENV like
 // runtimeEnvsAllowDevelopmentDefaults(). Async operation log replay is a JS
 // debugging concern, not a security boundary — it should key off the JS
@@ -204,24 +211,25 @@ function logSanitizedConfig() {
 const KNOWN_WEAK_PASSWORDS = new Set(['devPassword', 'myPassword1', 'password', 'changeme', 'admin', 'secret', 'test', 'renderer'].map((p) => p.toLowerCase()));
 const MIN_PASSWORD_LENGTH = 16;
 function validatePasswordForProduction(aConfig) {
-    const isProductionLike = !runtimeEnvsAllowDevelopmentDefaults();
+    const runtimeEnvs = normalizedRuntimeEnvs();
+    const isProductionLike = !runtimeEnvsAllowDevelopmentDefaults(runtimeEnvs);
     if (!aConfig.password || aConfig.password.trim() === '') {
         if (isProductionLike) {
-            return ('RENDERER_PASSWORD must be set in production-like environments ' +
+            return (`RENDERER_PASSWORD must be set in production-like environments ` +
                 `(NODE_ENV: "${env.NODE_ENV ?? '(not set)'}", RAILS_ENV: "${env.RAILS_ENV ?? '(not set)'}").` +
-                '\n\n' +
-                'In development and test environments, the renderer password is optional and no authentication\n' +
-                'is required. In all other environments, you must explicitly configure a password to secure\n' +
-                'communication between Rails and the Node Renderer.\n\n' +
-                'To fix this, set the RENDERER_PASSWORD environment variable:\n\n' +
-                '  export RENDERER_PASSWORD="your-secure-password"\n\n' +
-                'Or pass it in the config object:\n\n' +
-                '  reactOnRailsProNodeRenderer({ password: process.env.RENDERER_PASSWORD });\n\n' +
-                'Environment matrix:\n' +
-                '  development — password optional (no authentication)\n' +
-                '  test        — password optional (no authentication)\n' +
-                '  (neither set) — treated as production-like; RENDERER_PASSWORD required\n' +
-                '  all other environments (staging, production, qa, preview, etc.) — RENDERER_PASSWORD required');
+                `\n\n` +
+                `In development and test environments, the renderer password is optional and no authentication\n` +
+                `is required. In all other environments, you must explicitly configure a password to secure\n` +
+                `communication between Rails and the Node Renderer.${unsetRuntimeEnvPasswordGuidance(runtimeEnvs)}\n\n` +
+                `To secure the renderer, set the RENDERER_PASSWORD environment variable:\n\n` +
+                `  export RENDERER_PASSWORD="your-secure-password"\n\n` +
+                `Or pass it in the config object:\n\n` +
+                `  reactOnRailsProNodeRenderer({ password: process.env.RENDERER_PASSWORD });\n\n` +
+                `Environment matrix:\n` +
+                `  development — password optional (no authentication)\n` +
+                `  test        — password optional (no authentication)\n` +
+                `  (both unset) — treated as production-like; RENDERER_PASSWORD required\n` +
+                `  all other environments (staging, production, qa, preview, etc.) — RENDERER_PASSWORD required`);
         }
         return null;
     }

package/lib/shared/licenseValidator.js

@@ -57,6 +57,7 @@ const licensePublicKey_js_1 = require("./licensePublicKey.js");
  * Valid license plan types.
  * Must match VALID_PLANS in react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb
  */
+// MIRROR VALUES OF: react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb
 const VALID_PLANS = ['paid', 'startup', 'nonprofit', 'education', 'oss', 'partner'];
 // Module-level state for caching license validation results.
 //

package/lib/shared/rscPeerSupport.d.ts

@@ -1,15 +1,12 @@
 export declare const RSC_PEER_SUPPORT: {
     readonly reactOnRailsRsc: {
-        readonly recommendedMin: "19.0.2";
+        readonly minimumVersion: "19.2.1";
+        readonly minimumPrereleaseVersion: "19.2.1-rc.0";
         readonly supportedMajor: 19;
     };
     readonly react: {
         readonly supportedMajor: 19;
         readonly supportedRanges: readonly [{
-            readonly rscMinor: 0;
-            readonly minor: 0;
-            readonly minPatch: 4;
-        }, {
             readonly rscMinor: 2;
             readonly minor: 2;
             readonly minPatch: 7;

package/lib/shared/rscPeerSupport.js

@@ -15,21 +15,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSC_PEER_SUPPORT = void 0;
-// Single source of truth for react-on-rails-pro's RSC peer compatibility window.
-// This is the only value to bump when compatibility changes.
+// Node-renderer source of truth for react-on-rails-pro's RSC peer compatibility window.
+// Ruby Doctor mirrors these values and has a parity spec to catch cross-language drift.
 //
-// `recommendedMin` deliberately starts at the stable floor we currently recommend.
-// Raise it to the stable `react-on-rails-rsc` release (expected 19.0.5) once
-// 19.0.5-rc.7 is promoted, which activates the warn tier for anyone still on an older
-// 19.x build.
-// Bump tracked by https://github.com/shakacode/react_on_rails/issues/3632
-// (the stable 19.0.5 ship/pin is tracked by issue #3634).
+// `minimumVersion` is the React on Rails 17 RSC floor. Keep it in sync with the
+// Ruby Doctor/generator constants that install and diagnose the same Pro RSC
+// package line. The 19.2.1 line pairs with React/React DOM 19.2.7 and carries
+// the coordinated RSC fixes required by the Pro RSC renderer path.
+// `minimumPrereleaseVersion` keeps the 17.0 RC soak installable until the stable
+// 19.2.1 package is published without accepting older prereleases on the same
+// tuple. When it is set, keep its core tuple equal to `minimumVersion`.
 exports.RSC_PEER_SUPPORT = {
-    reactOnRailsRsc: { recommendedMin: '19.0.2', supportedMajor: 19 },
+    reactOnRailsRsc: { minimumVersion: '19.2.1', minimumPrereleaseVersion: '19.2.1-rc.0', supportedMajor: 19 },
     react: {
         supportedMajor: 19,
         supportedRanges: [
-            { rscMinor: 0, minor: 0, minPatch: 4 },
             // React 19.2.7 is the coordinated floor for react-on-rails-rsc 19.2.x.
             { rscMinor: 2, minor: 2, minPatch: 7 },
         ],

package/lib/shared/runRscPeerCompatibilityCheck.js

@@ -106,11 +106,6 @@ function runRscPeerCompatibilityCheck(options = {}) {
     });
     if (result.level === 'ok')
         return;
-    if (result.level === 'warn') {
-        // DISABLE_ENV only downgrades hard errors; warnings still fire so operators see the degraded-version signal.
-        log_js_1.default.warn(result.message);
-        return;
-    }
     if (env[DISABLE_ENV] === '1') {
         log_js_1.default.warn(`${result.message}\n(Version check downgraded to a warning via ${DISABLE_ENV}.)`);
         return;

package/lib/shared/sharedConsoleHistory.js

@@ -41,6 +41,9 @@ function replayConsoleOnRenderer(consoleHistory) {
 // AsyncLocalStorage is available in Node.js 12.17.0 and later versions
 const canUseAsyncLocalStorage = () => typeof async_hooks_1.AsyncLocalStorage !== 'undefined' && (0, configBuilder_js_1.getConfig)().replayServerAsyncOperationLogs;
 class SharedConsoleHistory {
+    asyncLocalStorageIfEnabled;
+    isRunningSyncOperation;
+    syncHistory;
     constructor() {
         if (canUseAsyncLocalStorage()) {
             this.asyncLocalStorageIfEnabled = new async_hooks_1.AsyncLocalStorage();

package/lib/shared/utils.d.ts

@@ -6,6 +6,7 @@ import type { RenderResult } from '../worker/vm.js';
 import { remapStackTrace } from '../worker/vmSourceMapSupport.js';
 export declare const TRUNCATION_FILLER = "\n... TRUNCATED ...\n";
 export declare const SHUTDOWN_WORKER_MESSAGE = "NODE_RENDERER_SHUTDOWN_WORKER";
+export declare const SHUTDOWN_WORKER_ACK_MESSAGE = "NODE_RENDERER_SHUTDOWN_WORKER_ACK";
 export declare function workerIdLabel(): number | "NO WORKER ID";
 export declare function smartTrim(value: unknown, maxLength?: number): string | null;
 export interface ResponseResult {
@@ -35,6 +36,7 @@ export type RequestInfo = {
  * registration-scoped remapper to avoid rewriting unrelated bundle paths.
  */
 export declare function formatExceptionMessage(request: RequestInfo, error: unknown, context?: string, stackRemapper?: typeof remapStackTrace): string;
+export declare function validateAssetFilename(filename: unknown): string;
 export declare function saveMultipartFile(multipartFile: MultipartFile, destinationPath: string): Promise<void>;
 export interface Asset {
     type: 'asset';