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

package/dist/cjs/plugins/telemetry.js

@@ -1,1287 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __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__, {
-    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
-});