@bleedingdev/modern-js-prod-server 3.2.0-ultramodern.0

package/dist/cjs/server/index.js

@@ -0,0 +1,579 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    Server: ()=>Server
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const contractGateAutopilot_js_namespaceObject = require("../libs/contractGateAutopilot.js");
+const loadConfig_js_namespaceObject = require("../libs/loadConfig.js");
+const metrics_js_namespaceObject = require("../libs/metrics.js");
+const runtimeFallbackWorkerLane_js_namespaceObject = require("../libs/runtimeFallbackWorkerLane.js");
+const telemetry_js_namespaceObject = require("../libs/telemetry.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const external_modernServerSplit_js_namespaceObject = require("./modernServerSplit.js");
+const CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = 1;
+const DEFAULT_RUNTIME_FALLBACK_GATE_NAME = 'runtime-mf-fallback-health';
+const DEFAULT_RUNTIME_FALLBACK_FAILURE_HOLD_MS = 300000;
+const DEFAULT_RUNTIME_FALLBACK_MAX_BODY_BYTES = 16384;
+class Server {
+    async init({ disableHttpServer = false } = {
+        disableHttpServer: false
+    }) {
+        const { options } = this;
+        await this.loadServerEnv(options);
+        this.initServerConfig(options);
+        await this.injectContext(this.runner, options);
+        this.runner = await this.createHookRunner();
+        await this.initConfig(this.runner, options);
+        await this.initTelemetry(options);
+        await this.injectContext(this.runner, options);
+        this.server = this.serverImpl(options);
+        await this.runPrepareHook(this.runner);
+        if (!disableHttpServer) this.app = await this.server.createHTTPServer(this.getRequestHandler());
+        {
+            const result = await this.runner.beforeServerInit({
+                app: this.app,
+                server: this.server
+            });
+            ({ app: this.app = this.app, server: this.server } = result);
+        }
+        await this.server.onInit(this.runner, this.app);
+        {
+            const result = await this.runner.afterServerInit({
+                app: this.app,
+                server: this.server
+            });
+            ({ app: this.app = this.app, server: this.server } = result);
+        }
+        return this;
+    }
+    runConfigHook(runner, serverConfig) {
+        const newServerConfig = runner.config(serverConfig || {});
+        return newServerConfig;
+    }
+    async runPrepareHook(runner) {
+        runner.prepare();
+    }
+    initServerConfig(options) {
+        const { pwd, serverConfigFile } = options;
+        const distDirectory = external_path_default().join(pwd, options.config.output.path || 'dist');
+        const serverConfigPath = (0, loadConfig_js_namespaceObject.getServerConfigPath)(distDirectory, serverConfigFile);
+        const serverConfig = (0, loadConfig_js_namespaceObject.requireConfig)(serverConfigPath);
+        this.serverConfig = serverConfig;
+    }
+    async initConfig(runner, options) {
+        const { pwd, config } = options;
+        const { serverConfig } = this;
+        const finalServerConfig = this.runConfigHook(runner, serverConfig);
+        const resolvedConfigPath = (0, utils_namespaceObject.ensureAbsolutePath)(pwd, external_path_default().join(config.output.path || 'dist', utils_namespaceObject.OUTPUT_CONFIG_FILE));
+        options.config = (0, loadConfig_js_namespaceObject.loadConfig)({
+            cliConfig: config,
+            serverConfig: finalServerConfig,
+            resolvedConfigPath
+        });
+    }
+    async initTelemetry(options) {
+        const telemetryConfig = options.config.server?.telemetry;
+        if (!telemetryConfig) return;
+        const hasEnabledExporters = (0, telemetry_js_namespaceObject.hasEnabledTelemetryExporters)(telemetryConfig);
+        if (true !== telemetryConfig.enabled && !hasEnabledExporters) return;
+        const registry = new telemetry_js_namespaceObject.TelemetryRegistry({
+            service: telemetryConfig.service || options.appContext?.metaName || 'modern-js',
+            module: telemetryConfig.module || 'server',
+            environment: telemetryConfig.environment || process.env.MODERN_ENV || process.env.NODE_ENV || 'development',
+            samplingRate: telemetryConfig.samplingRate,
+            flushIntervalMs: telemetryConfig.flushIntervalMs,
+            maxBatchSize: telemetryConfig.maxBatchSize,
+            maxQueueSize: telemetryConfig.maxQueueSize,
+            redactionKeys: telemetryConfig.redactionKeys,
+            slo: {
+                queueUtilizationWarnThreshold: telemetryConfig.slo?.queueUtilizationWarnThreshold,
+                queueDroppedWarnThreshold: telemetryConfig.slo?.queueDroppedWarnThreshold,
+                alertCooldownMs: telemetryConfig.slo?.alertCooldownMs,
+                onAlert: (alert)=>{
+                    options.logger?.warn(`[telemetry.slo] ${alert.type} threshold=${alert.threshold} value=${alert.value} depth=${alert.queueDepth}/${alert.queueCapacity} dropped=${alert.totalDropped}`);
+                }
+            }
+        });
+        if (telemetryConfig.exporters?.otlp?.enabled) await registry.register((0, telemetry_js_namespaceObject.createOtlpTelemetryExporter)(telemetryConfig.exporters.otlp));
+        if (telemetryConfig.exporters?.victoriaMetrics?.enabled) await registry.register((0, telemetry_js_namespaceObject.createVictoriaMetricsTelemetryExporter)(telemetryConfig.exporters.victoriaMetrics));
+        try {
+            await registry.startupHealthCheck({
+                failLoud: telemetryConfig.failLoudStartup ?? true
+            });
+        } catch (error) {
+            await registry.shutdown();
+            throw error;
+        }
+        options.metrics = (0, telemetry_js_namespaceObject.createTelemetryAwareMetrics)(options.metrics || metrics_js_namespaceObject.metrics, registry);
+        this.telemetryRegistry = registry;
+        const canaryConfig = telemetryConfig.canary;
+        if (canaryConfig?.enabled) {
+            const contractGates = canaryConfig.contractGates;
+            const orchestrator = new telemetry_js_namespaceObject.TelemetryCanaryOrchestrator({
+                registry,
+                evaluationIntervalMs: canaryConfig.evaluationIntervalMs,
+                minConsecutiveHealthyEvaluations: canaryConfig.minConsecutiveHealthyEvaluations,
+                rollbackConsecutiveFailures: canaryConfig.rollbackConsecutiveFailures,
+                maxQueueUtilization: canaryConfig.maxQueueUtilization,
+                maxTotalDropped: canaryConfig.maxTotalDropped,
+                maxUnhealthyExporters: canaryConfig.maxUnhealthyExporters,
+                requiredContractGates: Object.keys(contractGates || {}),
+                onPromote: (decision)=>{
+                    options.logger?.info(`[telemetry.canary] promoted after ${decision.consecutiveHealthy} healthy evaluations`);
+                    this.emitCanaryDecisionMetric(registry, decision, 'promote');
+                },
+                onRollback: (decision)=>{
+                    options.logger?.error(`[telemetry.canary] rollback triggered failures=${decision.failures.map((item)=>item.reason).join(',')}`);
+                    this.emitCanaryDecisionMetric(registry, decision, 'rollback');
+                }
+            });
+            if (contractGates) orchestrator.setContractGates(contractGates);
+            this.canaryOrchestrator = orchestrator;
+            orchestrator.start();
+            const autopilotEnabled = canaryConfig.autopilot?.enabled ?? true;
+            if (autopilotEnabled) {
+                const gateSnapshotPath = this.resolveContractGateSnapshotPath(options, canaryConfig.autopilot?.gateSnapshotPath);
+                this.contractGateAutopilot = new contractGateAutopilot_js_namespaceObject.ContractGateAutopilot({
+                    orchestrator,
+                    gateSnapshotPath,
+                    pollIntervalMs: canaryConfig.autopilot?.pollIntervalMs,
+                    gateStaleAfterMs: canaryConfig.autopilot?.gateStaleAfterMs,
+                    logger: {
+                        info: (message)=>{
+                            options.logger?.info(message);
+                        },
+                        warn: (message)=>{
+                            options.logger?.warn(message);
+                        }
+                    }
+                });
+                await this.contractGateAutopilot.start();
+                const runtimeSignalConfig = canaryConfig.autopilot?.runtimeFallbackSignal;
+                const runtimeSignalEnabled = runtimeSignalConfig?.enabled ?? true;
+                if (runtimeSignalEnabled) {
+                    const workerLaneConfig = runtimeSignalConfig?.workerLane;
+                    const workerLaneEnabledFromEnv = 'true' === process.env.MODERN_RUNTIME_FALLBACK_WORKER_LANE;
+                    const workerLaneEnabled = 'boolean' == typeof workerLaneConfig?.enabled ? workerLaneConfig.enabled : workerLaneEnabledFromEnv;
+                    this.runtimeFallbackSignalConfig = {
+                        endpoint: (0, telemetry_js_namespaceObject.resolveRuntimeFallbackSignalEndpoint)(runtimeSignalConfig?.endpoint),
+                        gateName: runtimeSignalConfig?.gateName?.trim() || DEFAULT_RUNTIME_FALLBACK_GATE_NAME,
+                        gateSnapshotPath,
+                        failureHoldMs: Math.max(1000, runtimeSignalConfig?.failureHoldMs ?? DEFAULT_RUNTIME_FALLBACK_FAILURE_HOLD_MS),
+                        maxBodyBytes: Math.max(512, runtimeSignalConfig?.maxBodyBytes ?? DEFAULT_RUNTIME_FALLBACK_MAX_BODY_BYTES),
+                        auth: (0, telemetry_js_namespaceObject.normalizeRuntimeFallbackSignalAuthConfig)(runtimeSignalConfig?.auth),
+                        trustPolicy: (0, telemetry_js_namespaceObject.normalizeRuntimeFallbackTrustPolicy)(runtimeSignalConfig?.trustPolicy),
+                        runtimeState: (0, telemetry_js_namespaceObject.createRuntimeFallbackSignalRuntimeState)(),
+                        workerLane: {
+                            enabled: workerLaneEnabled,
+                            timeoutMs: Math.max(25, workerLaneConfig?.timeoutMs ?? runtimeFallbackWorkerLane_js_namespaceObject.DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS),
+                            workerSuccessCount: 0,
+                            fallbackToMainThreadCount: 0
+                        }
+                    };
+                }
+            }
+            orchestrator.evaluate();
+        }
+    }
+    resolveContractGateSnapshotPath(options, configuredPath) {
+        const rawPath = configuredPath || process.env.MODERN_CONTRACT_GATES_FILE || '.modern/contract-gates.json';
+        if (external_path_default().isAbsolute(rawPath)) return rawPath;
+        return external_path_default().resolve(options.pwd, rawPath);
+    }
+    emitCanaryDecisionMetric(registry, decision, action) {
+        try {
+            registry.enqueueMetric({
+                name: `telemetry.canary.${action}`,
+                value: 1,
+                unit: 'count',
+                tags: {
+                    action,
+                    state: decision.state,
+                    failures: String(decision.failures.length)
+                }
+            });
+        } catch (_error) {}
+    }
+    async close() {
+        if (this.contractGateAutopilot) {
+            this.contractGateAutopilot.stop();
+            this.contractGateAutopilot = void 0;
+        }
+        this.runtimeFallbackSignalConfig = void 0;
+        if (this.canaryOrchestrator) this.canaryOrchestrator.stop();
+        if (this.telemetryRegistry) await this.telemetryRegistry.shutdown();
+        if (!this.app) return;
+        await new Promise((resolve)=>{
+            this.app.close(()=>resolve());
+        });
+    }
+    listen(options, listener) {
+        const callback = ()=>{
+            listener?.();
+        };
+        if ('object' == typeof options) {
+            if (process.env.PORT) Object.assign(options, {
+                port: process.env.PORT
+            });
+            this.app.listen(options, callback);
+        } else this.app.listen(process.env.PORT || options || 8080, callback);
+    }
+    getRequestHandler() {
+        const requestHandler = this.server.getRequestHandler();
+        return (req, res, next)=>{
+            if (this.shouldHandleRuntimeStatus(req)) return void this.handleRuntimeStatus(req, res);
+            if (this.shouldHandleRuntimeFallbackSignal(req)) return void this.handleRuntimeFallbackSignal(req, res);
+            return requestHandler(req, res, next);
+        };
+    }
+    shouldHandleRuntimeFallbackSignal(req) {
+        const runtimeSignalConfig = this.runtimeFallbackSignalConfig;
+        if (!runtimeSignalConfig) return false;
+        if ('POST' !== (req.method || 'GET').toUpperCase()) return false;
+        const pathName = this.getRequestPath(req.url);
+        return pathName === runtimeSignalConfig.endpoint;
+    }
+    shouldHandleRuntimeStatus(req) {
+        if ('GET' !== (req.method || 'GET').toUpperCase()) return false;
+        const pathName = this.getRequestPath(req.url);
+        return pathName === this.runtimeStatusEndpoint;
+    }
+    getRequestPath(urlValue) {
+        try {
+            const requestUrl = new URL(urlValue || '/', 'http://127.0.0.1');
+            return requestUrl.pathname;
+        } catch (_error) {
+            return '/';
+        }
+    }
+    async readRequestBody(req, maxBodyBytes) {
+        return new Promise((resolve, reject)=>{
+            const chunks = [];
+            let totalBytes = 0;
+            let done = false;
+            const cleanup = ()=>{
+                req.off('data', onData);
+                req.off('end', onEnd);
+                req.off('error', onError);
+            };
+            const onData = (chunk)=>{
+                if (done) return;
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                totalBytes += buffer.length;
+                if (totalBytes > maxBodyBytes) {
+                    const error = new Error('runtime fallback signal payload too large');
+                    error.code = 'PAYLOAD_TOO_LARGE';
+                    done = true;
+                    cleanup();
+                    reject(error);
+                    return;
+                }
+                chunks.push(buffer);
+            };
+            const onEnd = ()=>{
+                if (done) return;
+                done = true;
+                cleanup();
+                resolve(Buffer.concat(chunks).toString('utf8'));
+            };
+            const onError = (error)=>{
+                if (done) return;
+                done = true;
+                cleanup();
+                reject(error);
+            };
+            req.on('data', onData);
+            req.on('end', onEnd);
+            req.on('error', onError);
+        });
+    }
+    async handleRuntimeFallbackSignal(req, res) {
+        const runtimeSignalConfig = this.runtimeFallbackSignalConfig;
+        if (!runtimeSignalConfig) {
+            res.statusCode = 404;
+            res.end();
+            return;
+        }
+        try {
+            (0, telemetry_js_namespaceObject.enforceRuntimeFallbackSignalAuthToken)(this.getRequestHeader(req, runtimeSignalConfig.auth.headerName), runtimeSignalConfig.auth);
+            const rawBody = await this.readRequestBody(req, runtimeSignalConfig.maxBodyBytes);
+            const payload = (0, telemetry_js_namespaceObject.parseRuntimeFallbackSignalPayloadFromRawBody)(rawBody, runtimeSignalConfig.maxBodyBytes);
+            const trustResult = (0, telemetry_js_namespaceObject.enforceRuntimeFallbackSignalTrustPolicy)(payload, {
+                trustPolicy: runtimeSignalConfig.trustPolicy,
+                runtimeState: runtimeSignalConfig.runtimeState
+            });
+            if (trustResult.deduped) {
+                res.statusCode = 202;
+                res.setHeader('content-type', 'application/json');
+                res.end('{"ok":true,"deduped":true}');
+                return;
+            }
+            let persistedByWorkerLane = false;
+            if (runtimeSignalConfig.workerLane.enabled) {
+                const workerResult = await (0, runtimeFallbackWorkerLane_js_namespaceObject.persistRuntimeFallbackContractGateInWorker)({
+                    snapshotPath: runtimeSignalConfig.gateSnapshotPath,
+                    gateName: runtimeSignalConfig.gateName,
+                    failureHoldMs: runtimeSignalConfig.failureHoldMs,
+                    payload: payload,
+                    schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION
+                }, {
+                    enabled: true,
+                    timeoutMs: runtimeSignalConfig.workerLane.timeoutMs
+                });
+                if (workerResult.ok) {
+                    persistedByWorkerLane = true;
+                    runtimeSignalConfig.workerLane.workerSuccessCount += 1;
+                    runtimeSignalConfig.workerLane.lastError = void 0;
+                    const payloadRecord = payload;
+                    const reason = 'string' == typeof payloadRecord.reason ? payloadRecord.reason : 'runtime_fallback';
+                    const phase = 'string' == typeof payloadRecord.phase ? payloadRecord.phase : 'unknown';
+                    const appName = 'string' == typeof payloadRecord.appName ? payloadRecord.appName : 'unknown';
+                    this.options.logger?.warn(`[telemetry.canary.autopilot] runtime fallback signal gate=${runtimeSignalConfig.gateName} reason=${reason} phase=${phase} app=${appName} workerLane=true`);
+                } else {
+                    runtimeSignalConfig.workerLane.fallbackToMainThreadCount += 1;
+                    runtimeSignalConfig.workerLane.lastError = workerResult.error;
+                    this.options.logger?.warn(`[telemetry.canary.autopilot] runtime fallback worker lane fallback: ${workerResult.error || 'unknown_error'}`);
+                }
+            }
+            if (!persistedByWorkerLane) await this.persistRuntimeFallbackContractGate(payload, runtimeSignalConfig);
+            res.statusCode = 202;
+            res.setHeader('content-type', 'application/json');
+            res.end('{"ok":true}');
+        } catch (error) {
+            const signalError = error;
+            res.statusCode = (0, telemetry_js_namespaceObject.getRuntimeSignalErrorStatusCode)(signalError);
+            res.setHeader('content-type', 'application/json');
+            res.end(`{"ok":false,"error":${JSON.stringify(signalError instanceof Error ? signalError.message : String(signalError))}}`);
+            this.options.logger?.warn(`[telemetry.canary.autopilot] runtime fallback signal rejected: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async handleRuntimeStatus(req, res) {
+        try {
+            if (this.runtimeFallbackSignalConfig?.auth.enabled) (0, telemetry_js_namespaceObject.enforceRuntimeFallbackSignalAuthToken)(this.getRequestHeader(req, this.runtimeFallbackSignalConfig.auth.headerName), this.runtimeFallbackSignalConfig.auth);
+            res.statusCode = 200;
+            res.setHeader('content-type', 'application/json');
+            res.end(JSON.stringify(this.buildRuntimeStatusPayload()));
+        } catch (error) {
+            const signalError = error;
+            res.statusCode = (0, telemetry_js_namespaceObject.getRuntimeSignalErrorStatusCode)(signalError);
+            res.setHeader('content-type', 'application/json');
+            res.end(`{"ok":false,"error":${JSON.stringify(signalError instanceof Error ? signalError.message : String(signalError))}}`);
+        }
+    }
+    buildRuntimeStatusPayload() {
+        const telemetry = this.telemetryRegistry ? {
+            enabled: true,
+            queueStats: this.telemetryRegistry.getQueueStats(),
+            exporterHealth: this.telemetryRegistry.getExporterHealth()
+        } : {
+            enabled: false,
+            queueStats: null,
+            exporterHealth: []
+        };
+        const canary = this.canaryOrchestrator ? {
+            enabled: true,
+            ...this.canaryOrchestrator.getStatusSnapshot()
+        } : {
+            enabled: false
+        };
+        const runtimeFallbackSignal = this.runtimeFallbackSignalConfig ? {
+            enabled: true,
+            endpoint: this.runtimeFallbackSignalConfig.endpoint,
+            gateName: this.runtimeFallbackSignalConfig.gateName,
+            failureHoldMs: this.runtimeFallbackSignalConfig.failureHoldMs,
+            maxBodyBytes: this.runtimeFallbackSignalConfig.maxBodyBytes,
+            auth: {
+                enabled: this.runtimeFallbackSignalConfig.auth.enabled,
+                headerName: this.runtimeFallbackSignalConfig.auth.headerName
+            },
+            trustPolicy: {
+                allowedApps: this.runtimeFallbackSignalConfig.trustPolicy.allowedApps,
+                allowedEntryOrigins: this.runtimeFallbackSignalConfig.trustPolicy.allowedEntryOrigins,
+                enforceRuntimeDigest: this.runtimeFallbackSignalConfig.trustPolicy.enforceRuntimeDigest,
+                expectedRuntimeDigestsCount: Object.keys(this.runtimeFallbackSignalConfig.trustPolicy.expectedRuntimeDigests).length,
+                maxSignalsPerWindow: this.runtimeFallbackSignalConfig.trustPolicy.maxSignalsPerWindow,
+                windowMs: this.runtimeFallbackSignalConfig.trustPolicy.windowMs,
+                dedupeWindowMs: this.runtimeFallbackSignalConfig.trustPolicy.dedupeWindowMs
+            },
+            workerLane: {
+                enabled: this.runtimeFallbackSignalConfig.workerLane.enabled,
+                timeoutMs: this.runtimeFallbackSignalConfig.workerLane.timeoutMs,
+                workerSuccessCount: this.runtimeFallbackSignalConfig.workerLane.workerSuccessCount,
+                fallbackToMainThreadCount: this.runtimeFallbackSignalConfig.workerLane.fallbackToMainThreadCount,
+                lastError: this.runtimeFallbackSignalConfig.workerLane.lastError
+            }
+        } : {
+            enabled: false
+        };
+        return {
+            ok: true,
+            timestamp: Date.now(),
+            telemetry,
+            canary,
+            runtimeFallbackSignal
+        };
+    }
+    getRequestHeader(req, headerName) {
+        const raw = req.headers[headerName.toLowerCase()];
+        if (Array.isArray(raw)) return raw[0];
+        if ('string' == typeof raw) return raw;
+    }
+    async persistRuntimeFallbackContractGate(payload, runtimeSignalConfig) {
+        const now = Date.now();
+        const snapshotPath = runtimeSignalConfig.gateSnapshotPath;
+        let snapshot = {
+            schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+            updatedAt: now,
+            gates: {}
+        };
+        if (await utils_namespaceObject.fs.pathExists(snapshotPath)) try {
+            const raw = await external_fs_namespaceObject.promises.readFile(snapshotPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && 'object' == typeof parsed) snapshot = {
+                schemaVersion: 'number' == typeof parsed.schemaVersion ? parsed.schemaVersion : CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: 'number' == typeof parsed.updatedAt ? parsed.updatedAt : now,
+                gates: parsed.gates && 'object' == typeof parsed.gates ? parsed.gates : {}
+            };
+        } catch (_error) {
+            snapshot = {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: now,
+                gates: {}
+            };
+        }
+        const reason = 'string' == typeof payload.reason ? payload.reason : 'runtime_fallback';
+        const phase = 'string' == typeof payload.phase ? payload.phase : 'unknown';
+        const appName = 'string' == typeof payload.appName ? payload.appName : 'unknown';
+        const entry = 'string' == typeof payload.entry ? payload.entry : void 0;
+        snapshot.schemaVersion = CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+        snapshot.updatedAt = now;
+        snapshot.gates = snapshot.gates || {};
+        snapshot.gates[runtimeSignalConfig.gateName] = {
+            passed: false,
+            reason: `runtime_fallback:${reason} phase=${phase} app=${appName}${entry ? ` entry=${entry}` : ''}`,
+            updatedAt: now,
+            expiresAt: now + runtimeSignalConfig.failureHoldMs,
+            source: 'runtime-mf-fallback-signal',
+            metadata: payload
+        };
+        await external_fs_namespaceObject.promises.mkdir(external_path_default().dirname(snapshotPath), {
+            recursive: true
+        });
+        await external_fs_namespaceObject.promises.writeFile(snapshotPath, `${JSON.stringify(snapshot, null, 2)}\n`);
+        this.options.logger?.warn(`[telemetry.canary.autopilot] runtime fallback signal gate=${runtimeSignalConfig.gateName} reason=${reason} phase=${phase} app=${appName}`);
+    }
+    async render(req, res, url) {
+        return this.server.render(req, res, url);
+    }
+    async createHookRunner() {
+        server_core_namespaceObject.serverManager.clear();
+        const { options } = this;
+        const { internalPlugins = utils_namespaceObject.INTERNAL_SERVER_PLUGINS, pwd, plugins = [] } = options;
+        const serverPlugins = this.serverConfig.plugins || [];
+        const loadedPlugins = (0, server_core_namespaceObject.loadPlugins)(pwd, [
+            ...serverPlugins,
+            ...plugins
+        ], {
+            internalPlugins
+        });
+        (0, external_utils_js_namespaceObject.debug)('plugins', loadedPlugins);
+        loadedPlugins.forEach((p)=>{
+            server_core_namespaceObject.serverManager.usePlugin(p);
+        });
+        const hooksRunner = await server_core_namespaceObject.serverManager.init();
+        return hooksRunner;
+    }
+    async injectContext(runner, options) {
+        const appContext = this.initAppContext();
+        const { config, pwd } = options;
+        server_core_namespaceObject.ConfigContext.set(config);
+        server_core_namespaceObject.AppContext.set({
+            ...appContext,
+            distDirectory: external_path_default().join(pwd, config.output.path || 'dist')
+        });
+    }
+    initAppContext() {
+        const { options } = this;
+        const { pwd: appDirectory, plugins = [], config, appContext } = options;
+        const serverPlugins = plugins.map((p)=>({
+                server: p
+            }));
+        return {
+            appDirectory,
+            apiDirectory: appContext?.apiDirectory,
+            lambdaDirectory: appContext?.lambdaDirectory,
+            sharedDirectory: appContext?.sharedDirectory || external_path_default().resolve(appDirectory, utils_namespaceObject.SHARED_DIR),
+            distDirectory: external_path_default().join(appDirectory, config.output.path || 'dist'),
+            plugins: serverPlugins
+        };
+    }
+    async loadServerEnv(options) {
+        const { pwd: appDirectory } = options;
+        const serverEnv = process.env.MODERN_ENV;
+        const defaultEnvPath = external_path_default().resolve(appDirectory, ".env");
+        const serverEnvPath = external_path_default().resolve(appDirectory, `.env.${serverEnv}`);
+        for (const envPath of [
+            serverEnvPath,
+            defaultEnvPath
+        ])if (await utils_namespaceObject.fs.pathExists(envPath) && !(await utils_namespaceObject.fs.stat(envPath)).isDirectory()) {
+            const envConfig = utils_namespaceObject.dotenv.config({
+                path: envPath
+            });
+            (0, utils_namespaceObject.dotenvExpand)(envConfig);
+        }
+    }
+    constructor(options){
+        this.serverImpl = external_modernServerSplit_js_namespaceObject.createProdServer;
+        this.runtimeStatusEndpoint = telemetry_js_namespaceObject.DEFAULT_RUNTIME_STATUS_ENDPOINT;
+        options.logger = options.logger || (0, utils_namespaceObject.createLogger)({
+            level: 'warn'
+        });
+        options.metrics = options.metrics || metrics_js_namespaceObject.metrics;
+        this.options = options;
+        this.serverConfig = {};
+    }
+}
+exports.Server = __webpack_exports__.Server;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Server"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});