@bleedingdev/modern-js-prod-server 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/dist/cjs/server/index.js

@@ -1,583 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    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
-});