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

package/dist/cjs/plugins/telemetry.js

@@ -0,0 +1,1283 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT: ()=>DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT,
+    DEFAULT_RUNTIME_STATUS_ENDPOINT: ()=>DEFAULT_RUNTIME_STATUS_ENDPOINT,
+    TelemetryCanaryOrchestrator: ()=>TelemetryCanaryOrchestrator,
+    TelemetryRegistry: ()=>TelemetryRegistry,
+    TelemetryStartupHealthError: ()=>TelemetryStartupHealthError,
+    createOtlpTelemetryExporter: ()=>createOtlpTelemetryExporter,
+    createRuntimeFallbackSignalRuntimeState: ()=>createRuntimeFallbackSignalRuntimeState,
+    createRuntimeSignalError: ()=>createRuntimeSignalError,
+    createTelemetryAwareMetrics: ()=>createTelemetryAwareMetrics,
+    createVictoriaMetricsTelemetryExporter: ()=>createVictoriaMetricsTelemetryExporter,
+    enforceRuntimeFallbackSignalAuthToken: ()=>enforceRuntimeFallbackSignalAuthToken,
+    enforceRuntimeFallbackSignalTrustPolicy: ()=>enforceRuntimeFallbackSignalTrustPolicy,
+    getRuntimeSignalErrorStatusCode: ()=>getRuntimeSignalErrorStatusCode,
+    hasEnabledTelemetryExporters: ()=>hasEnabledTelemetryExporters,
+    injectTelemetryPlugin: ()=>injectTelemetryPlugin,
+    normalizeRuntimeFallbackSignalAuthConfig: ()=>normalizeRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackTrustPolicy: ()=>normalizeRuntimeFallbackTrustPolicy,
+    parseRuntimeFallbackSignalPayloadFromRawBody: ()=>parseRuntimeFallbackSignalPayloadFromRawBody,
+    resolveRuntimeFallbackSignalEndpoint: ()=>resolveRuntimeFallbackSignalEndpoint
+});
+const external_contractGateAutopilot_js_namespaceObject = require("./contractGateAutopilot.js");
+const external_contractGateSnapshotStore_js_namespaceObject = require("./contractGateSnapshotStore.js");
+class TelemetryStartupHealthError extends Error {
+    constructor(failedExporters){
+        super(`Telemetry startup health check failed for exporters: ${failedExporters.map((item)=>item.name).join(', ')}`), this.code = 'TELEMETRY_EXPORTER_STARTUP_HEALTH_FAILED';
+        this.name = 'TelemetryStartupHealthError';
+        this.failedExporters = failedExporters;
+    }
+}
+const TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/i;
+const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
+const DEFAULT_VM_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
+const DEFAULT_TIMEOUT_MS = 5000;
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_STATUS_ENDPOINT = '/_modern/runtime/status';
+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;
+const DEFAULT_RUNTIME_FALLBACK_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+const DEFAULT_RUNTIME_FALLBACK_TRUST_MAX_SIGNALS_PER_WINDOW = 30;
+const DEFAULT_RUNTIME_FALLBACK_TRUST_WINDOW_MS = 60000;
+const DEFAULT_RUNTIME_FALLBACK_TRUST_DEDUPE_WINDOW_MS = 10000;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function redactObject(value, redactionKeys) {
+    if (!isRecord(value)) return;
+    const output = {};
+    for (const [key, nested] of Object.entries(value)){
+        if (redactionKeys.has(key)) {
+            output[key] = '[REDACTED]';
+            continue;
+        }
+        if (Array.isArray(nested)) {
+            output[key] = nested.map((item)=>{
+                if (isRecord(item)) return redactObject(item, redactionKeys);
+                return item;
+            });
+            continue;
+        }
+        if (isRecord(nested)) {
+            output[key] = redactObject(nested, redactionKeys);
+            continue;
+        }
+        output[key] = nested;
+    }
+    return output;
+}
+function normalizeLabels(labels) {
+    if (!labels) return;
+    const normalized = {};
+    for (const [key, value] of Object.entries(labels))if (null != value) normalized[key] = String(value);
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function parseTraceparent(header) {
+    if (!header) return;
+    const match = header.trim().match(TRACEPARENT_REGEX);
+    if (!match) return;
+    const traceId = match[1]?.toLowerCase();
+    const spanId = match[2]?.toLowerCase();
+    if (!traceId || !spanId) return;
+    return {
+        traceId,
+        spanId
+    };
+}
+function extractError(args) {
+    for (const arg of args)if (arg instanceof Error) return {
+        name: arg.name,
+        message: arg.message,
+        stack: arg.stack
+    };
+}
+function toTelemetryEnvelope(event, input) {
+    const base = {
+        timestamp: Date.now(),
+        service: input.service,
+        module: input.module,
+        environment: input.environment,
+        ...input.traceId ? {
+            traceId: input.traceId
+        } : {},
+        ...input.spanId ? {
+            spanId: input.spanId
+        } : {},
+        ...input.attributes ? {
+            attributes: input.attributes
+        } : {}
+    };
+    if ('log' === event.type) {
+        const payload = event.payload;
+        const args = payload.args || [];
+        const signalType = 'trace' === payload.level ? 'trace' : 'log';
+        return {
+            ...base,
+            signalType,
+            name: payload.message,
+            level: payload.level,
+            attributes: {
+                ...base.attributes || {},
+                args
+            },
+            error: extractError(args)
+        };
+    }
+    if ('timing' === event.type) return {
+        ...base,
+        signalType: 'metric',
+        name: event.payload.name,
+        value: event.payload.dur,
+        unit: 'ms',
+        tags: normalizeLabels(event.payload.tags),
+        attributes: {
+            ...base.attributes || {},
+            desc: event.payload.desc,
+            args: event.payload.args
+        }
+    };
+    return {
+        ...base,
+        signalType: 'metric',
+        name: event.payload.name,
+        value: 1,
+        unit: 'count',
+        tags: normalizeLabels(event.payload.tags),
+        attributes: {
+            ...base.attributes || {},
+            args: event.payload.args
+        }
+    };
+}
+async function postWithTimeout(options) {
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), options.timeoutMs);
+    if ('function' == typeof timer.unref) timer.unref();
+    try {
+        const response = await fetch(options.endpoint, {
+            method: 'POST',
+            body: options.body,
+            headers: options.headers,
+            signal: controller.signal
+        });
+        if (!response.ok) throw new Error(`Telemetry exporter request failed: ${response.status} ${response.statusText}`);
+    } finally{
+        clearTimeout(timer);
+    }
+}
+function sanitizeMetricName(value) {
+    return value.replace(/[^a-zA-Z0-9_:]/g, '_').replace(/_+/g, '_');
+}
+function escapeLabelValue(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+function toPrometheusLine(envelope, metricPrefix) {
+    const metricName = sanitizeMetricName(`${metricPrefix}_${envelope.signalType}_${envelope.name}`);
+    const labels = {
+        service: envelope.service,
+        module: envelope.module,
+        environment: envelope.environment,
+        ...envelope.level ? {
+            level: envelope.level
+        } : {},
+        ...envelope.traceId ? {
+            trace_id: envelope.traceId
+        } : {},
+        ...envelope.spanId ? {
+            span_id: envelope.spanId
+        } : {},
+        ...envelope.tags || {}
+    };
+    const labelPairs = Object.entries(labels).sort(([a], [b])=>a.localeCompare(b)).map(([key, value])=>`${sanitizeMetricName(key)}="${escapeLabelValue(value)}"`);
+    const labelText = labelPairs.length > 0 ? `{${labelPairs.join(',')}}` : '';
+    const value = 'number' == typeof envelope.value && Number.isFinite(envelope.value) ? envelope.value : 1;
+    const timestampMs = envelope.timestamp;
+    return `${metricName}${labelText} ${value} ${timestampMs}`;
+}
+function createOtlpTelemetryExporter(options = {}) {
+    const endpoint = options.endpoint || DEFAULT_OTLP_ENDPOINT;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const headers = {
+        'content-type': 'application/json',
+        ...options.headers || {}
+    };
+    return {
+        name: 'otlp',
+        async emit (batch) {
+            if (0 === batch.length) return;
+            const body = JSON.stringify({
+                resource: {
+                    service: batch[0]?.service,
+                    module: batch[0]?.module,
+                    environment: batch[0]?.environment
+                },
+                emittedAt: Date.now(),
+                events: batch
+            });
+            await postWithTimeout({
+                endpoint,
+                body,
+                headers,
+                timeoutMs
+            });
+        }
+    };
+}
+function createVictoriaMetricsTelemetryExporter(options = {}) {
+    const endpoint = options.endpoint || DEFAULT_VM_ENDPOINT;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const metricPrefix = sanitizeMetricName(options.metricPrefix || 'modernjs');
+    const headers = {
+        'content-type': 'text/plain; version=0.0.4',
+        ...options.headers || {}
+    };
+    return {
+        name: 'victoria-metrics',
+        async emit (batch) {
+            if (0 === batch.length) return;
+            const lines = batch.map((item)=>toPrometheusLine(item, metricPrefix));
+            await postWithTimeout({
+                endpoint,
+                body: `${lines.join('\n')}\n`,
+                headers,
+                timeoutMs
+            });
+        }
+    };
+}
+class TelemetryRegistry {
+    async register(exporter) {
+        this.exporters.push(exporter);
+        this.exporterHealth.set(exporter.name, {
+            name: exporter.name,
+            healthy: true,
+            failures: 0
+        });
+        if (exporter.init) try {
+            await exporter.init({
+                service: this.service,
+                module: this.module,
+                environment: this.environment
+            });
+            this.markExporterHealthy(exporter.name);
+        } catch (error) {
+            this.markExporterFailure(exporter.name, error);
+            throw error;
+        }
+        else this.markExporterHealthy(exporter.name);
+    }
+    getOrCreateExporterHealth(name) {
+        const existing = this.exporterHealth.get(name);
+        if (existing) return existing;
+        const next = {
+            name,
+            healthy: true,
+            failures: 0
+        };
+        this.exporterHealth.set(name, next);
+        return next;
+    }
+    markExporterHealthy(name) {
+        const status = this.getOrCreateExporterHealth(name);
+        status.healthy = true;
+        status.lastSuccessAt = Date.now();
+        status.lastError = void 0;
+    }
+    markExporterFailure(name, error) {
+        const status = this.getOrCreateExporterHealth(name);
+        status.healthy = false;
+        status.failures += 1;
+        status.lastFailureAt = Date.now();
+        status.lastError = error instanceof Error ? error.message : String(error);
+    }
+    maybeEmitSloAlert(type, value, threshold) {
+        if (!this.onSloAlert || value < threshold) return;
+        const now = Date.now();
+        const lastTimestamp = this.lastSloAlertAt.get(type) ?? 0;
+        if (now - lastTimestamp < this.alertCooldownMs) return;
+        this.lastSloAlertAt.set(type, now);
+        const queueDepth = this.queue.length;
+        try {
+            this.onSloAlert({
+                timestamp: now,
+                service: this.service,
+                module: this.module,
+                environment: this.environment,
+                type,
+                value,
+                threshold,
+                queueDepth,
+                queueCapacity: this.maxQueueSize,
+                queueUtilization: queueDepth / this.maxQueueSize,
+                totalDropped: this.totalDroppedCount
+            });
+        } catch (_error) {}
+    }
+    enqueue(envelope) {
+        if (this.samplingRate < 1 && Math.random() > this.samplingRate) return;
+        const redactedEnvelope = this.redactionKeys.size > 0 ? {
+            ...envelope,
+            attributes: redactObject(envelope.attributes, this.redactionKeys)
+        } : envelope;
+        if (this.queue.length >= this.maxQueueSize) {
+            this.queue.shift();
+            this.droppedCount += 1;
+            this.totalDroppedCount += 1;
+            this.maybeEmitSloAlert('queue.drop', this.totalDroppedCount, this.queueDroppedWarnThreshold);
+        }
+        this.queue.push(redactedEnvelope);
+        this.maybeEmitSloAlert('queue.utilization', this.queue.length / this.maxQueueSize, this.queueUtilizationWarnThreshold);
+        if (this.queue.length >= this.maxBatchSize) this.flush();
+    }
+    enqueueMetric(input) {
+        this.enqueue({
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: input.name,
+            value: input.value,
+            unit: input.unit || 'count',
+            traceId: input.traceId,
+            spanId: input.spanId,
+            parentSpanId: input.parentSpanId,
+            tags: input.tags,
+            attributes: input.attributes
+        });
+    }
+    enqueueLog(input) {
+        this.enqueue({
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'log',
+            name: input.name,
+            level: input.level,
+            traceId: input.traceId,
+            spanId: input.spanId,
+            parentSpanId: input.parentSpanId,
+            tags: input.tags,
+            attributes: input.attributes,
+            error: input.error
+        });
+    }
+    enqueueTrace(input) {
+        this.enqueue({
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'trace',
+            name: input.name,
+            traceId: input.traceId,
+            spanId: input.spanId,
+            parentSpanId: input.parentSpanId,
+            tags: input.tags,
+            attributes: input.attributes
+        });
+    }
+    buildDroppedEnvelope(droppedCount) {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: 'telemetry.queue.dropped',
+            value: droppedCount,
+            unit: 'count',
+            tags: {
+                reason: 'queue_backpressure'
+            }
+        };
+    }
+    buildQueueDepthEnvelope(queueDepth) {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: 'telemetry.queue.depth',
+            value: queueDepth,
+            unit: 'count',
+            tags: {
+                capacity: String(this.maxQueueSize)
+            }
+        };
+    }
+    buildQueueUtilizationEnvelope(queueDepth) {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: 'telemetry.queue.utilization',
+            value: queueDepth / this.maxQueueSize,
+            unit: 'ratio',
+            tags: {
+                capacity: String(this.maxQueueSize)
+            }
+        };
+    }
+    async emitBatch(batch) {
+        const results = await Promise.allSettled(this.exporters.map(async (exporter)=>{
+            await exporter.emit(batch);
+            return exporter.name;
+        }));
+        for (const [index, result] of results.entries()){
+            const exporterName = this.exporters[index]?.name || `exporter-${index}`;
+            if ('rejected' === result.status) {
+                this.markExporterFailure(exporterName, result.reason);
+                continue;
+            }
+            this.markExporterHealthy(exporterName);
+        }
+    }
+    buildStartupProbeEnvelope() {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'log',
+            name: 'telemetry.exporter.startup_probe',
+            level: 'info',
+            tags: {
+                phase: 'startup'
+            },
+            attributes: {
+                source: 'TelemetryRegistry'
+            }
+        };
+    }
+    async startupHealthCheck(options) {
+        if (0 === this.exporters.length) return;
+        const probeBatch = [
+            this.buildStartupProbeEnvelope()
+        ];
+        const failedExporters = [];
+        await Promise.all(this.exporters.map(async (exporter)=>{
+            try {
+                await exporter.emit(probeBatch);
+                this.markExporterHealthy(exporter.name);
+            } catch (error) {
+                this.markExporterFailure(exporter.name, error);
+                const status = this.exporterHealth.get(exporter.name);
+                if (status) failedExporters.push({
+                    ...status
+                });
+            }
+        }));
+        if ((options?.failLoud ?? true) && failedExporters.length > 0) throw new TelemetryStartupHealthError(failedExporters);
+    }
+    getExporterHealth() {
+        return Array.from(this.exporterHealth.values()).map((item)=>({
+                ...item
+            }));
+    }
+    getQueueStats() {
+        return {
+            depth: this.queue.length,
+            capacity: this.maxQueueSize,
+            utilization: this.queue.length / this.maxQueueSize,
+            pendingDropped: this.droppedCount,
+            totalDropped: this.totalDroppedCount
+        };
+    }
+    async flushInternal() {
+        const queueDepthBeforeFlush = this.queue.length;
+        if (queueDepthBeforeFlush > 0) {
+            this.queue.unshift(this.buildQueueUtilizationEnvelope(queueDepthBeforeFlush));
+            this.queue.unshift(this.buildQueueDepthEnvelope(queueDepthBeforeFlush));
+        }
+        if (this.droppedCount > 0) {
+            const droppedCount = this.droppedCount;
+            this.droppedCount = 0;
+            this.queue.unshift(this.buildDroppedEnvelope(droppedCount));
+        }
+        if (0 === this.queue.length) return;
+        if (0 === this.exporters.length) {
+            this.queue.length = 0;
+            return;
+        }
+        while(this.queue.length > 0){
+            const batch = this.queue.splice(0, this.maxBatchSize);
+            await this.emitBatch(batch);
+        }
+        await Promise.allSettled(this.exporters.map(async (exporter)=>{
+            if (exporter.flush) await exporter.flush();
+        }));
+    }
+    flush() {
+        if (this.flushing) return this.flushing;
+        this.flushing = this.flushInternal().finally(()=>{
+            this.flushing = null;
+        });
+        return this.flushing;
+    }
+    async shutdown() {
+        if (this.flushTimer) clearInterval(this.flushTimer);
+        await this.flush();
+        await Promise.allSettled(this.exporters.map(async (exporter)=>{
+            if (exporter.shutdown) await exporter.shutdown();
+        }));
+    }
+    constructor(options){
+        this.exporters = [];
+        this.queue = [];
+        this.droppedCount = 0;
+        this.totalDroppedCount = 0;
+        this.flushing = null;
+        this.exporterHealth = new Map();
+        this.lastSloAlertAt = new Map();
+        this.service = options.service;
+        this.module = options.module;
+        this.environment = options.environment;
+        this.samplingRate = clamp(options.samplingRate ?? 1, 0, 1);
+        this.maxBatchSize = Math.max(1, options.maxBatchSize ?? 50);
+        this.maxQueueSize = Math.max(1, options.maxQueueSize ?? 1000);
+        this.flushIntervalMs = Math.max(50, options.flushIntervalMs ?? 1000);
+        this.redactionKeys = new Set(options.redactionKeys || []);
+        this.queueUtilizationWarnThreshold = clamp(options.slo?.queueUtilizationWarnThreshold ?? 0.8, 0, 1);
+        this.queueDroppedWarnThreshold = Math.max(1, options.slo?.queueDroppedWarnThreshold ?? 1);
+        this.alertCooldownMs = Math.max(0, options.slo?.alertCooldownMs ?? 60000);
+        this.onSloAlert = options.slo?.onAlert;
+        this.flushTimer = setInterval(()=>{
+            this.flush();
+        }, this.flushIntervalMs);
+        if ('function' == typeof this.flushTimer.unref) this.flushTimer.unref();
+    }
+}
+class TelemetryCanaryOrchestrator {
+    setRequiredContractGates(gates) {
+        this.requiredContractGates = Array.from(new Set(gates.map((item)=>item.trim()).filter(Boolean)));
+    }
+    addRequiredContractGate(name) {
+        const normalizedName = name.trim();
+        if (!normalizedName) return;
+        if (!this.requiredContractGates.includes(normalizedName)) this.requiredContractGates.push(normalizedName);
+    }
+    setContractGate(name, passed, reason) {
+        this.contractGates.set(name, {
+            name,
+            passed,
+            reason,
+            updatedAt: Date.now()
+        });
+    }
+    setContractGates(gates) {
+        for (const [name, value] of Object.entries(gates)){
+            if ('boolean' == typeof value) {
+                this.setContractGate(name, value);
+                continue;
+            }
+            this.setContractGate(name, value.passed, value.reason);
+        }
+    }
+    resetToCanary() {
+        this.state = 'canary';
+        this.consecutiveHealthy = 0;
+        this.consecutiveFailures = 0;
+    }
+    collectFailures() {
+        const failures = [];
+        const queueStats = this.registry.getQueueStats();
+        const unhealthyExporterCount = this.registry.getExporterHealth().filter((item)=>!item.healthy).length;
+        if (queueStats.utilization > this.maxQueueUtilization) failures.push({
+            reason: 'queue_utilization',
+            threshold: this.maxQueueUtilization,
+            value: queueStats.utilization
+        });
+        if (queueStats.totalDropped > this.maxTotalDropped) failures.push({
+            reason: 'queue_dropped',
+            threshold: this.maxTotalDropped,
+            value: queueStats.totalDropped
+        });
+        if (unhealthyExporterCount > this.maxUnhealthyExporters) failures.push({
+            reason: 'unhealthy_exporter',
+            threshold: this.maxUnhealthyExporters,
+            value: unhealthyExporterCount
+        });
+        for (const gateName of this.requiredContractGates){
+            const gate = this.contractGates.get(gateName);
+            if (!gate) {
+                failures.push({
+                    reason: 'contract_gate_missing',
+                    gate: gateName,
+                    message: `Contract gate "${gateName}" is missing`
+                });
+                continue;
+            }
+            if (!gate.passed) failures.push({
+                reason: 'contract_gate_failed',
+                gate: gateName,
+                message: gate.reason || `Contract gate "${gateName}" is not passing`
+            });
+        }
+        return {
+            failures,
+            queueStats,
+            unhealthyExporterCount
+        };
+    }
+    evaluate() {
+        const now = Date.now();
+        const { failures, queueStats, unhealthyExporterCount } = this.collectFailures();
+        let action = 'hold';
+        if (failures.length > 0) {
+            this.consecutiveHealthy = 0;
+            this.consecutiveFailures += 1;
+            if ('rolled_back' !== this.state && this.consecutiveFailures >= this.rollbackConsecutiveFailures) {
+                this.state = 'rolled_back';
+                action = 'rollback';
+            }
+        } else {
+            this.consecutiveFailures = 0;
+            this.consecutiveHealthy += 1;
+            if ('canary' === this.state && this.consecutiveHealthy >= this.minConsecutiveHealthyEvaluations) {
+                this.state = 'promoted';
+                action = 'promote';
+            }
+        }
+        const decision = {
+            timestamp: now,
+            action,
+            state: this.state,
+            consecutiveHealthy: this.consecutiveHealthy,
+            consecutiveFailures: this.consecutiveFailures,
+            failures,
+            queueStats,
+            unhealthyExporterCount,
+            contractGates: Array.from(this.contractGates.values()).map((item)=>({
+                    ...item
+                }))
+        };
+        try {
+            this.onEvaluate?.(decision);
+        } catch (_error) {}
+        if ('promote' === action) try {
+            this.onPromote?.(decision);
+        } catch (_error) {}
+        if ('rollback' === action) try {
+            this.onRollback?.(decision);
+        } catch (_error) {}
+        return decision;
+    }
+    getStatusSnapshot() {
+        const now = Date.now();
+        const { failures, queueStats, unhealthyExporterCount } = this.collectFailures();
+        return {
+            timestamp: now,
+            state: this.state,
+            consecutiveHealthy: this.consecutiveHealthy,
+            consecutiveFailures: this.consecutiveFailures,
+            queueStats,
+            unhealthyExporterCount,
+            requiredContractGates: [
+                ...this.requiredContractGates
+            ],
+            contractGates: Array.from(this.contractGates.values()).map((item)=>({
+                    ...item
+                })),
+            failurePreview: failures
+        };
+    }
+    start() {
+        if (this.evaluationTimer) return;
+        this.evaluationTimer = setInterval(()=>{
+            this.evaluate();
+        }, this.evaluationIntervalMs);
+        if ('function' == typeof this.evaluationTimer.unref) this.evaluationTimer.unref();
+    }
+    stop() {
+        if (this.evaluationTimer) {
+            clearInterval(this.evaluationTimer);
+            this.evaluationTimer = void 0;
+        }
+    }
+    constructor(options){
+        this.requiredContractGates = [];
+        this.contractGates = new Map();
+        this.state = 'canary';
+        this.consecutiveHealthy = 0;
+        this.consecutiveFailures = 0;
+        this.registry = options.registry;
+        this.evaluationIntervalMs = Math.max(250, options.evaluationIntervalMs ?? 15000);
+        this.minConsecutiveHealthyEvaluations = Math.max(1, options.minConsecutiveHealthyEvaluations ?? 3);
+        this.rollbackConsecutiveFailures = Math.max(1, options.rollbackConsecutiveFailures ?? 2);
+        this.maxQueueUtilization = clamp(options.maxQueueUtilization ?? 0.8, 0, 1);
+        this.maxTotalDropped = Math.max(0, options.maxTotalDropped ?? 0);
+        this.maxUnhealthyExporters = Math.max(0, options.maxUnhealthyExporters ?? 0);
+        this.setRequiredContractGates(options.requiredContractGates || []);
+        this.onEvaluate = options.onEvaluate;
+        this.onPromote = options.onPromote;
+        this.onRollback = options.onRollback;
+    }
+}
+function normalizeMetricsInput(prefixOrTags, tags) {
+    if ('string' == typeof prefixOrTags) return {
+        prefix: prefixOrTags,
+        tags: tags || {}
+    };
+    if (isRecord(prefixOrTags)) return {
+        prefix: void 0,
+        tags: prefixOrTags
+    };
+    return {
+        prefix: void 0,
+        tags: tags || {}
+    };
+}
+function normalizeMetricName(name, prefix) {
+    return prefix && prefix.length > 0 ? `${prefix}.${name}` : name;
+}
+function toTelemetryMetricTags(tags) {
+    const output = {};
+    for (const [key, value] of Object.entries(tags))if (null != value) output[key] = String(value);
+    return output;
+}
+function getTraceContext(tags) {
+    const traceId = 'string' == typeof tags.trace_id ? tags.trace_id : 'string' == typeof tags.traceId ? tags.traceId : void 0;
+    const spanId = 'string' == typeof tags.span_id ? tags.span_id : 'string' == typeof tags.spanId ? tags.spanId : void 0;
+    const parentSpanId = 'string' == typeof tags.parent_span_id ? tags.parent_span_id : 'string' == typeof tags.parentSpanId ? tags.parentSpanId : void 0;
+    return {
+        traceId,
+        spanId,
+        parentSpanId
+    };
+}
+const createTelemetryAwareMetrics = (baseMetrics, registry)=>{
+    const emitCounter = (name, value, prefixOrTags, tags)=>{
+        const normalized = normalizeMetricsInput(prefixOrTags, tags);
+        baseMetrics.emitCounter(name, value, normalized.prefix, normalized.tags);
+        try {
+            const metricName = normalizeMetricName(name, normalized.prefix);
+            const traceContext = getTraceContext(normalized.tags);
+            registry.enqueueMetric({
+                name: metricName,
+                value,
+                unit: 'count',
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                parentSpanId: traceContext.parentSpanId,
+                tags: toTelemetryMetricTags(normalized.tags),
+                attributes: normalized.tags
+            });
+        } catch (_error) {}
+    };
+    const emitTimer = (name, value, prefixOrTags, tags)=>{
+        const normalized = normalizeMetricsInput(prefixOrTags, tags);
+        baseMetrics.emitTimer(name, value, normalized.prefix, normalized.tags);
+        try {
+            const metricName = normalizeMetricName(name, normalized.prefix);
+            const traceContext = getTraceContext(normalized.tags);
+            registry.enqueueMetric({
+                name: metricName,
+                value,
+                unit: 'ms',
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                parentSpanId: traceContext.parentSpanId,
+                tags: toTelemetryMetricTags(normalized.tags),
+                attributes: normalized.tags
+            });
+        } catch (_error) {}
+    };
+    return {
+        ...baseMetrics,
+        emitCounter,
+        emitTimer
+    };
+};
+function resolveRuntimeFallbackSignalEndpoint(configuredEndpoint) {
+    const rawEndpoint = configuredEndpoint?.trim();
+    if (!rawEndpoint) return DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+    if (rawEndpoint.startsWith('/')) return rawEndpoint;
+    try {
+        return new URL(rawEndpoint).pathname || DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+    } catch (_error) {
+        return `/${rawEndpoint.replace(/^\/+/, '')}`;
+    }
+}
+function createRuntimeSignalError(message, code) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+}
+function getUtf8ByteLength(input) {
+    if ("u" > typeof Buffer) return Buffer.byteLength(input);
+    return new TextEncoder().encode(input).length;
+}
+function normalizeRuntimeSignalOrigin(value) {
+    if ('string' != typeof value || 0 === value.trim().length) return;
+    try {
+        return new URL(value).origin;
+    } catch (_error) {
+        return;
+    }
+}
+function normalizeRuntimeSignalAppName(payload) {
+    if ('string' != typeof payload.appName) return 'unknown';
+    const normalized = payload.appName.trim();
+    return normalized.length > 0 ? normalized : 'unknown';
+}
+function normalizeRuntimeSignalRuntimeDigest(payload) {
+    if ('string' == typeof payload.runtimeDigest && payload.runtimeDigest.trim()) return payload.runtimeDigest.trim();
+    const metadata = payload.metadata;
+    if (metadata && 'object' == typeof metadata && !Array.isArray(metadata) && 'string' == typeof metadata.runtimeDigest) {
+        const digest = String(metadata.runtimeDigest).trim();
+        if (digest) return digest;
+    }
+}
+function normalizeRuntimeFallbackSignalAuthConfig(configured) {
+    const headerName = 'string' == typeof configured?.headerName && configured.headerName.trim() ? configured.headerName.trim().toLowerCase() : DEFAULT_RUNTIME_FALLBACK_AUTH_HEADER;
+    const expectedFromEnv = 'string' == typeof configured?.expectedValueEnv && configured.expectedValueEnv.trim().length > 0 ? process.env[configured.expectedValueEnv.trim()] : void 0;
+    const expectedFromConfig = 'string' == typeof configured?.expectedValue && configured.expectedValue.trim().length > 0 ? configured.expectedValue.trim() : void 0;
+    const expectedValue = expectedFromConfig || expectedFromEnv;
+    const enabled = configured?.enabled === true;
+    if (enabled && !expectedValue) throw new Error('[telemetry.canary.autopilot.runtimeFallbackSignal] auth.enabled is true but no expected token is configured');
+    return {
+        enabled,
+        headerName,
+        expectedValue
+    };
+}
+function enforceRuntimeFallbackSignalAuthToken(token, authConfig) {
+    if (!authConfig.enabled) return;
+    if (!token || token !== authConfig.expectedValue) throw createRuntimeSignalError('runtime fallback signal auth failed', 'UNAUTHORIZED');
+}
+function enforceRuntimeFallbackSignalAuth(c, runtimeSignalConfig) {
+    enforceRuntimeFallbackSignalAuthToken(c.req.header(runtimeSignalConfig.auth.headerName), runtimeSignalConfig.auth);
+}
+function normalizeRuntimeFallbackTrustPolicy(configured) {
+    const allowedApps = Array.isArray(configured?.allowedApps) ? configured.allowedApps.map((item)=>'string' == typeof item ? item.trim() : '').filter(Boolean) : [];
+    const allowedEntryOrigins = Array.isArray(configured?.allowedEntryOrigins) ? configured.allowedEntryOrigins.map((item)=>normalizeRuntimeSignalOrigin(item)).filter((item)=>Boolean(item)) : [];
+    const expectedRuntimeDigestsRaw = configured?.expectedRuntimeDigests || {};
+    const expectedRuntimeDigests = {};
+    Object.entries(expectedRuntimeDigestsRaw).forEach(([appName, digest])=>{
+        if ('string' == typeof appName && appName.trim().length > 0 && 'string' == typeof digest && digest.trim().length > 0) expectedRuntimeDigests[appName.trim()] = digest.trim();
+    });
+    return {
+        allowedApps,
+        allowedEntryOrigins,
+        expectedRuntimeDigests,
+        enforceRuntimeDigest: configured?.enforceRuntimeDigest === true,
+        maxSignalsPerWindow: Math.max(1, Math.floor(configured?.maxSignalsPerWindow ?? DEFAULT_RUNTIME_FALLBACK_TRUST_MAX_SIGNALS_PER_WINDOW)),
+        windowMs: Math.max(1000, Math.floor(configured?.windowMs ?? DEFAULT_RUNTIME_FALLBACK_TRUST_WINDOW_MS)),
+        dedupeWindowMs: Math.max(0, Math.floor(configured?.dedupeWindowMs ?? DEFAULT_RUNTIME_FALLBACK_TRUST_DEDUPE_WINDOW_MS))
+    };
+}
+function createRuntimeFallbackSignalRuntimeState() {
+    return {
+        rateLimitBySource: new Map(),
+        dedupeByFingerprint: new Map()
+    };
+}
+function cleanupRuntimeFallbackSignalRuntimeState(now, runtimeState, trustPolicy) {
+    const dedupeExpiryMs = Math.max(trustPolicy.dedupeWindowMs, trustPolicy.windowMs, 1000);
+    runtimeState.dedupeByFingerprint.forEach((lastSeenAt, fingerprint)=>{
+        if (now - lastSeenAt > dedupeExpiryMs) runtimeState.dedupeByFingerprint.delete(fingerprint);
+    });
+    runtimeState.rateLimitBySource.forEach((state, source)=>{
+        if (now - state.windowStartedAt > 2 * trustPolicy.windowMs) runtimeState.rateLimitBySource.delete(source);
+    });
+}
+function enforceRuntimeFallbackSignalTrustPolicy(payload, runtimeSignalContext) {
+    const { trustPolicy, runtimeState } = runtimeSignalContext;
+    const now = Date.now();
+    cleanupRuntimeFallbackSignalRuntimeState(now, runtimeState, trustPolicy);
+    const appName = normalizeRuntimeSignalAppName(payload);
+    const entryOrigin = normalizeRuntimeSignalOrigin(payload.entry);
+    const runtimeDigest = normalizeRuntimeSignalRuntimeDigest(payload);
+    if (trustPolicy.allowedApps.length > 0 && !trustPolicy.allowedApps.includes(appName)) throw createRuntimeSignalError(`runtime fallback signal app "${appName}" is not trusted`, 'UNTRUSTED_SOURCE');
+    if (trustPolicy.allowedEntryOrigins.length > 0) {
+        if (!entryOrigin || !trustPolicy.allowedEntryOrigins.includes(entryOrigin)) throw createRuntimeSignalError(`runtime fallback signal entry origin "${entryOrigin || 'unknown'}" is not trusted`, 'UNTRUSTED_SOURCE');
+    }
+    const expectedDigest = trustPolicy.expectedRuntimeDigests[appName];
+    if (expectedDigest && runtimeDigest !== expectedDigest) throw createRuntimeSignalError(`runtime fallback runtimeDigest mismatch for app "${appName}"`, 'UNTRUSTED_SOURCE');
+    if (trustPolicy.enforceRuntimeDigest && !runtimeDigest) throw createRuntimeSignalError(`runtime fallback signal for app "${appName}" is missing runtimeDigest`, 'UNTRUSTED_SOURCE');
+    const dedupeFingerprint = JSON.stringify({
+        appName,
+        entryOrigin: entryOrigin || 'unknown',
+        reason: payload.reason || 'runtime_fallback',
+        phase: payload.phase || 'unknown',
+        runtimeDigest: runtimeDigest || 'unknown'
+    });
+    const dedupeWindowMs = trustPolicy.dedupeWindowMs;
+    if (dedupeWindowMs > 0) {
+        const lastSeenAt = runtimeState.dedupeByFingerprint.get(dedupeFingerprint);
+        runtimeState.dedupeByFingerprint.set(dedupeFingerprint, now);
+        if ('number' == typeof lastSeenAt && now - lastSeenAt <= dedupeWindowMs) return {
+            deduped: true
+        };
+    } else runtimeState.dedupeByFingerprint.set(dedupeFingerprint, now);
+    const sourceKey = `${appName}@${entryOrigin || 'unknown'}`;
+    const rateState = runtimeState.rateLimitBySource.get(sourceKey);
+    if (!rateState || now - rateState.windowStartedAt > trustPolicy.windowMs) runtimeState.rateLimitBySource.set(sourceKey, {
+        count: 1,
+        windowStartedAt: now
+    });
+    else {
+        if (rateState.count >= trustPolicy.maxSignalsPerWindow) throw createRuntimeSignalError(`runtime fallback signal rate-limited for source "${sourceKey}"`, 'RATE_LIMITED');
+        rateState.count += 1;
+    }
+    return {
+        deduped: false
+    };
+}
+function maybeWarnLegacyOtlpEndpoint(endpoint) {
+    if (!endpoint || !endpoint.includes('/v1/metrics')) return;
+    console.warn(`[telemetry] OTLP endpoint "${endpoint}" looks like a metrics path. UltraModern telemetry exporter expects log-style envelopes (default: ${DEFAULT_OTLP_ENDPOINT}).`);
+}
+async function parseRuntimeFallbackSignalPayload(c, maxBodyBytes) {
+    const contentLengthHeader = c.req.header('content-length');
+    if (contentLengthHeader) {
+        const contentLength = Number.parseInt(contentLengthHeader, 10);
+        if (Number.isFinite(contentLength) && contentLength > maxBodyBytes) throw createRuntimeSignalError('runtime fallback signal payload too large', 'PAYLOAD_TOO_LARGE');
+    }
+    const rawBody = await c.req.raw.text();
+    const payload = parseRuntimeFallbackSignalPayloadFromRawBody(rawBody, maxBodyBytes);
+    return {
+        rawBody,
+        payload
+    };
+}
+function parseRuntimeFallbackSignalPayloadFromRawBody(rawBody, maxBodyBytes) {
+    if (!rawBody || 0 === rawBody.trim().length) throw createRuntimeSignalError('runtime fallback signal body is empty', 'INVALID_PAYLOAD');
+    if (getUtf8ByteLength(rawBody) > maxBodyBytes) throw createRuntimeSignalError('runtime fallback signal payload too large', 'PAYLOAD_TOO_LARGE');
+    let payload;
+    try {
+        payload = JSON.parse(rawBody);
+    } catch (_error) {
+        throw createRuntimeSignalError('runtime fallback signal body must be valid JSON', 'INVALID_PAYLOAD');
+    }
+    if (!payload || 'object' != typeof payload || Array.isArray(payload)) throw createRuntimeSignalError('runtime fallback signal body must be a JSON object', 'INVALID_PAYLOAD');
+    return payload;
+}
+function getRuntimeSignalErrorStatusCode(signalError) {
+    if ('PAYLOAD_TOO_LARGE' === signalError.code) return 413;
+    if ('INVALID_PAYLOAD' === signalError.code) return 400;
+    if ('UNAUTHORIZED' === signalError.code) return 401;
+    if ('RATE_LIMITED' === signalError.code) return 429;
+    if ('UNTRUSTED_SOURCE' === signalError.code) return 403;
+    return 500;
+}
+async function persistRuntimeFallbackContractGate(payload, runtimeSignalConfig) {
+    const now = Date.now();
+    const gateSnapshotStore = await runtimeSignalConfig.gateSnapshotStore;
+    const snapshot = await gateSnapshotStore.readSnapshot() || {};
+    const existingGates = snapshot.gates && 'object' == typeof snapshot.gates ? snapshot.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 = 'number' == typeof snapshot.schemaVersion ? snapshot.schemaVersion : external_contractGateSnapshotStore_js_namespaceObject.CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+    snapshot.updatedAt = now;
+    snapshot.gates = {
+        ...existingGates,
+        [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 gateSnapshotStore.writeSnapshot(snapshot);
+}
+function 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) {}
+}
+const hasEnabledTelemetryExporters = (config)=>Boolean(config?.exporters?.otlp?.enabled || config?.exporters?.victoriaMetrics?.enabled);
+const injectTelemetryPlugin = ()=>({
+        name: '@modern-js/inject-telemetry',
+        setup (api) {
+            const serverConfig = api.getServerConfig();
+            const telemetryConfig = serverConfig?.server?.telemetry;
+            if (!telemetryConfig) return;
+            if (true !== telemetryConfig.enabled && !hasEnabledTelemetryExporters(telemetryConfig)) return;
+            const { middlewares, metaName, appDirectory } = api.getServerContext();
+            const serviceName = telemetryConfig.service || metaName || 'modern-js';
+            const moduleName = telemetryConfig.module || 'server';
+            const environmentName = telemetryConfig.environment || process.env.MODERN_ENV || process.env.NODE_ENV || 'development';
+            const registry = new TelemetryRegistry({
+                service: serviceName,
+                module: moduleName,
+                environment: environmentName,
+                samplingRate: telemetryConfig.samplingRate,
+                flushIntervalMs: telemetryConfig.flushIntervalMs,
+                maxBatchSize: telemetryConfig.maxBatchSize,
+                maxQueueSize: telemetryConfig.maxQueueSize,
+                redactionKeys: telemetryConfig.redactionKeys
+            });
+            let canaryOrchestrator;
+            let contractGateAutopilot;
+            let runtimeFallbackSignalConfig;
+            let gateSnapshotStorePromise;
+            const canaryConfig = telemetryConfig.canary;
+            if (canaryConfig?.enabled) {
+                const contractGates = canaryConfig.contractGates;
+                canaryOrchestrator = new 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)=>{
+                        emitCanaryDecisionMetric(registry, decision, 'promote');
+                    },
+                    onRollback: (decision)=>{
+                        emitCanaryDecisionMetric(registry, decision, 'rollback');
+                    }
+                });
+                if (contractGates) canaryOrchestrator.setContractGates(contractGates);
+                const autopilotEnabled = canaryConfig.autopilot?.enabled ?? true;
+                if (autopilotEnabled) {
+                    const gateSnapshotPath = (0, external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotPath)(appDirectory, canaryConfig.autopilot?.gateSnapshotPath);
+                    gateSnapshotStorePromise = (0, external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotStore)({
+                        appDirectory,
+                        gateSnapshotPath: gateSnapshotPath || external_contractGateSnapshotStore_js_namespaceObject.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH,
+                        stateStore: canaryConfig.autopilot?.stateStore
+                    });
+                    const runtimeSignalConfig = canaryConfig.autopilot?.runtimeFallbackSignal;
+                    const runtimeSignalEnabled = runtimeSignalConfig?.enabled ?? true;
+                    if (runtimeSignalEnabled && gateSnapshotStorePromise) runtimeFallbackSignalConfig = {
+                        endpoint: resolveRuntimeFallbackSignalEndpoint(runtimeSignalConfig?.endpoint),
+                        gateName: runtimeSignalConfig?.gateName?.trim() || DEFAULT_RUNTIME_FALLBACK_GATE_NAME,
+                        gateSnapshotStore: gateSnapshotStorePromise,
+                        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: normalizeRuntimeFallbackSignalAuthConfig(runtimeSignalConfig?.auth),
+                        trustPolicy: normalizeRuntimeFallbackTrustPolicy(runtimeSignalConfig?.trustPolicy),
+                        runtimeState: createRuntimeFallbackSignalRuntimeState()
+                    };
+                }
+            }
+            if (runtimeFallbackSignalConfig) {
+                const signalConfig = runtimeFallbackSignalConfig;
+                middlewares.push({
+                    name: 'telemetry-runtime-fallback-signal',
+                    path: signalConfig.endpoint,
+                    method: 'post',
+                    order: 'pre',
+                    handler: async (c)=>{
+                        try {
+                            enforceRuntimeFallbackSignalAuth(c, signalConfig);
+                            const { payload } = await parseRuntimeFallbackSignalPayload(c, signalConfig.maxBodyBytes);
+                            const trustResult = enforceRuntimeFallbackSignalTrustPolicy(payload, signalConfig);
+                            if (trustResult.deduped) return c.json({
+                                ok: true,
+                                deduped: true
+                            }, 202);
+                            await persistRuntimeFallbackContractGate(payload, signalConfig);
+                            return c.json({
+                                ok: true
+                            }, 202);
+                        } catch (error) {
+                            const signalError = error;
+                            const status = getRuntimeSignalErrorStatusCode(signalError);
+                            return c.json({
+                                ok: false,
+                                error: signalError instanceof Error ? signalError.message : String(signalError)
+                            }, status);
+                        }
+                    }
+                });
+            }
+            middlewares.push({
+                name: 'telemetry-runtime-status',
+                path: DEFAULT_RUNTIME_STATUS_ENDPOINT,
+                method: 'get',
+                order: 'pre',
+                handler: async (c)=>{
+                    try {
+                        if (runtimeFallbackSignalConfig?.auth.enabled) enforceRuntimeFallbackSignalAuthToken(c.req.header(runtimeFallbackSignalConfig.auth.headerName), runtimeFallbackSignalConfig.auth);
+                        return c.json({
+                            ok: true,
+                            timestamp: Date.now(),
+                            telemetry: {
+                                queueStats: registry.getQueueStats(),
+                                exporterHealth: registry.getExporterHealth()
+                            },
+                            canary: canaryOrchestrator ? {
+                                enabled: true,
+                                ...canaryOrchestrator.getStatusSnapshot()
+                            } : {
+                                enabled: false
+                            },
+                            runtimeFallbackSignal: runtimeFallbackSignalConfig ? {
+                                enabled: true,
+                                endpoint: runtimeFallbackSignalConfig.endpoint,
+                                gateName: runtimeFallbackSignalConfig.gateName,
+                                failureHoldMs: runtimeFallbackSignalConfig.failureHoldMs,
+                                maxBodyBytes: runtimeFallbackSignalConfig.maxBodyBytes,
+                                auth: {
+                                    enabled: runtimeFallbackSignalConfig.auth.enabled,
+                                    headerName: runtimeFallbackSignalConfig.auth.headerName
+                                },
+                                trustPolicy: {
+                                    allowedApps: runtimeFallbackSignalConfig.trustPolicy.allowedApps,
+                                    allowedEntryOrigins: runtimeFallbackSignalConfig.trustPolicy.allowedEntryOrigins,
+                                    enforceRuntimeDigest: runtimeFallbackSignalConfig.trustPolicy.enforceRuntimeDigest,
+                                    expectedRuntimeDigestsCount: Object.keys(runtimeFallbackSignalConfig.trustPolicy.expectedRuntimeDigests).length,
+                                    maxSignalsPerWindow: runtimeFallbackSignalConfig.trustPolicy.maxSignalsPerWindow,
+                                    windowMs: runtimeFallbackSignalConfig.trustPolicy.windowMs,
+                                    dedupeWindowMs: runtimeFallbackSignalConfig.trustPolicy.dedupeWindowMs
+                                }
+                            } : {
+                                enabled: false
+                            }
+                        });
+                    } catch (error) {
+                        const signalError = error;
+                        return c.json({
+                            ok: false,
+                            error: signalError instanceof Error ? signalError.message : String(signalError)
+                        }, getRuntimeSignalErrorStatusCode(signalError));
+                    }
+                }
+            });
+            middlewares.push({
+                name: 'inject-telemetry',
+                handler: async (c, next)=>{
+                    const monitors = c.get('monitors');
+                    if (monitors) {
+                        const traceContext = parseTraceparent(c.req.header('traceparent'));
+                        const monitor = (event)=>{
+                            registry.enqueue(toTelemetryEnvelope(event, {
+                                service: serviceName,
+                                module: moduleName,
+                                environment: environmentName,
+                                traceId: traceContext?.traceId,
+                                spanId: traceContext?.spanId,
+                                attributes: {
+                                    requestMethod: c.req.method,
+                                    requestPath: c.req.path
+                                }
+                            }));
+                        };
+                        monitors.push(monitor);
+                    }
+                    await next();
+                }
+            });
+            let prepared = false;
+            api.onPrepare(async ()=>{
+                if (prepared) return;
+                prepared = true;
+                if (telemetryConfig.exporters?.otlp?.enabled) {
+                    maybeWarnLegacyOtlpEndpoint(telemetryConfig.exporters.otlp.endpoint);
+                    await registry.register(createOtlpTelemetryExporter(telemetryConfig.exporters.otlp));
+                }
+                if (telemetryConfig.exporters?.victoriaMetrics?.enabled) await registry.register(createVictoriaMetricsTelemetryExporter(telemetryConfig.exporters.victoriaMetrics));
+                await registry.startupHealthCheck({
+                    failLoud: telemetryConfig.failLoudStartup ?? true
+                });
+                if (!canaryOrchestrator) return;
+                canaryOrchestrator.start();
+                if (gateSnapshotStorePromise) {
+                    const gateSnapshotStore = await gateSnapshotStorePromise;
+                    contractGateAutopilot = new external_contractGateAutopilot_js_namespaceObject.ContractGateAutopilot({
+                        orchestrator: canaryOrchestrator,
+                        gateSnapshotPath: (0, external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotPath)(appDirectory, canaryConfig?.autopilot?.gateSnapshotPath),
+                        gateSnapshotStore,
+                        pollIntervalMs: canaryConfig?.autopilot?.pollIntervalMs,
+                        gateStaleAfterMs: canaryConfig?.autopilot?.gateStaleAfterMs
+                    });
+                }
+                if (contractGateAutopilot) await contractGateAutopilot.start();
+                canaryOrchestrator.evaluate();
+            });
+        }
+    });
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+exports.DEFAULT_RUNTIME_STATUS_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_STATUS_ENDPOINT;
+exports.TelemetryCanaryOrchestrator = __webpack_exports__.TelemetryCanaryOrchestrator;
+exports.TelemetryRegistry = __webpack_exports__.TelemetryRegistry;
+exports.TelemetryStartupHealthError = __webpack_exports__.TelemetryStartupHealthError;
+exports.createOtlpTelemetryExporter = __webpack_exports__.createOtlpTelemetryExporter;
+exports.createRuntimeFallbackSignalRuntimeState = __webpack_exports__.createRuntimeFallbackSignalRuntimeState;
+exports.createRuntimeSignalError = __webpack_exports__.createRuntimeSignalError;
+exports.createTelemetryAwareMetrics = __webpack_exports__.createTelemetryAwareMetrics;
+exports.createVictoriaMetricsTelemetryExporter = __webpack_exports__.createVictoriaMetricsTelemetryExporter;
+exports.enforceRuntimeFallbackSignalAuthToken = __webpack_exports__.enforceRuntimeFallbackSignalAuthToken;
+exports.enforceRuntimeFallbackSignalTrustPolicy = __webpack_exports__.enforceRuntimeFallbackSignalTrustPolicy;
+exports.getRuntimeSignalErrorStatusCode = __webpack_exports__.getRuntimeSignalErrorStatusCode;
+exports.hasEnabledTelemetryExporters = __webpack_exports__.hasEnabledTelemetryExporters;
+exports.injectTelemetryPlugin = __webpack_exports__.injectTelemetryPlugin;
+exports.normalizeRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackTrustPolicy = __webpack_exports__.normalizeRuntimeFallbackTrustPolicy;
+exports.parseRuntimeFallbackSignalPayloadFromRawBody = __webpack_exports__.parseRuntimeFallbackSignalPayloadFromRawBody;
+exports.resolveRuntimeFallbackSignalEndpoint = __webpack_exports__.resolveRuntimeFallbackSignalEndpoint;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "DEFAULT_RUNTIME_STATUS_ENDPOINT",
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "createOtlpTelemetryExporter",
+    "createRuntimeFallbackSignalRuntimeState",
+    "createRuntimeSignalError",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "enforceRuntimeFallbackSignalAuthToken",
+    "enforceRuntimeFallbackSignalTrustPolicy",
+    "getRuntimeSignalErrorStatusCode",
+    "hasEnabledTelemetryExporters",
+    "injectTelemetryPlugin",
+    "normalizeRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackTrustPolicy",
+    "parseRuntimeFallbackSignalPayloadFromRawBody",
+    "resolveRuntimeFallbackSignalEndpoint"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});