@hazeljs/predictive-scaling 2.0.5

package/dist/events/event-scaling-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-scaling-registry.d.ts","sourceRoot":"","sources":["../../src/events/event-scaling-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC/D,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAC,MAAM,CAA6C;IAElE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAMlE,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,EAAE;IAIjD,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB,EAAE;IAY9D,MAAM,CAAC,KAAK,IAAI,IAAI;CAGrB;AAED,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,mBAAmB,GAC3B,MAAM,CAIR"}

package/dist/events/event-scaling-registry.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventScalingRegistry = void 0;
+exports.calculateEventBoostReplicas = calculateEventBoostReplicas;
+/**
+ * Registry for event-driven predictive scaling triggers.
+ */
+class EventScalingRegistry {
+    static register(scope, options) {
+        const existing = this.events.get(scope) ?? [];
+        existing.push({ ...options, scope });
+        this.events.set(scope, existing);
+    }
+    static get(scope) {
+        return [...(this.events.get(scope) ?? [])];
+    }
+    static findMatching(eventName) {
+        const matches = [];
+        for (const registrations of this.events.values()) {
+            for (const registration of registrations) {
+                if (registration.events.includes(eventName)) {
+                    matches.push(registration);
+                }
+            }
+        }
+        return matches;
+    }
+    static reset() {
+        this.events.clear();
+    }
+}
+exports.EventScalingRegistry = EventScalingRegistry;
+EventScalingRegistry.events = new Map();
+function calculateEventBoostReplicas(currentReplicas, options) {
+    const factor = options.scaleFactor ?? 2;
+    const maxScale = options.maxScale ?? 100;
+    return Math.min(maxScale, Math.max(currentReplicas, Math.ceil(currentReplicas * factor)));
+}

package/dist/forecast/ai-forecast-provider.d.ts

@@ -0,0 +1,18 @@
+import { ForecastProvider, ForecastResult, MetricName, MetricSample } from '../types';
+export interface AILlmForecastClient {
+    complete(messages: Array<{
+        role: 'system' | 'user';
+        content: string;
+    }>): Promise<string>;
+}
+/**
+ * Optional LLM-based forecast hook (Phase 2 bridge for @hazeljs/ai).
+ */
+export declare function createAIForecastProvider(client: AILlmForecastClient): ForecastProvider;
+export declare class ForecastEngine {
+    private readonly model;
+    private readonly provider?;
+    constructor(model?: import('../types').ForecastModel, provider?: ForecastProvider | undefined);
+    forecast(metric: MetricName, samples: MetricSample[], horizonMs: number): Promise<ForecastResult>;
+}
+//# sourceMappingURL=ai-forecast-provider.d.ts.map

package/dist/forecast/ai-forecast-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-forecast-provider.d.ts","sourceRoot":"","sources":["../../src/forecast/ai-forecast-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGtF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC1F;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,mBAAmB,GAAG,gBAAgB,CAuCtF;AAED,qBAAa,cAAc;IAEvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBADT,KAAK,GAAE,OAAO,UAAU,EAAE,aAAsC,EAChE,QAAQ,CAAC,EAAE,gBAAgB,YAAA;IAGxC,QAAQ,CACZ,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,YAAY,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;CAU3B"}

package/dist/forecast/ai-forecast-provider.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForecastEngine = void 0;
+exports.createAIForecastProvider = createAIForecastProvider;
+const forecast_engine_1 = require("./forecast-engine");
+/**
+ * Optional LLM-based forecast hook (Phase 2 bridge for @hazeljs/ai).
+ */
+function createAIForecastProvider(client) {
+    return {
+        async forecast(metric, samples, horizonMs) {
+            const prompt = [
+                'Predict the next metric value as JSON: {"predictedValue": number, "confidence": 0-1}',
+                `Metric: ${metric}`,
+                `HorizonMs: ${horizonMs}`,
+                `Samples: ${JSON.stringify(samples.slice(-50))}`,
+            ].join('\n');
+            const content = await client.complete([
+                {
+                    role: 'system',
+                    content: 'You are a time-series forecasting assistant. Respond with JSON only.',
+                },
+                { role: 'user', content: prompt },
+            ]);
+            try {
+                const parsed = JSON.parse(content.trim());
+                if (typeof parsed.predictedValue !== 'number') {
+                    return null;
+                }
+                return {
+                    metric,
+                    predictedValue: parsed.predictedValue,
+                    confidence: typeof parsed.confidence === 'number' ? parsed.confidence : 0.6,
+                    horizonMs,
+                    model: 'ai',
+                    at: Date.now(),
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+class ForecastEngine {
+    constructor(model = 'time-series-forecast', provider) {
+        this.model = model;
+        this.provider = provider;
+    }
+    async forecast(metric, samples, horizonMs) {
+        if (this.provider) {
+            const aiResult = await this.provider.forecast(metric, samples, horizonMs);
+            if (aiResult) {
+                return aiResult;
+            }
+        }
+        return (0, forecast_engine_1.runForecastModel)(this.model, metric, samples, horizonMs);
+    }
+}
+exports.ForecastEngine = ForecastEngine;

package/dist/forecast/forecast-engine.d.ts

@@ -0,0 +1,12 @@
+import { ForecastModel, ForecastResult, MetricName, MetricSample } from '../types';
+/**
+ * Holt's linear exponential smoothing for short-horizon demand forecasting.
+ */
+export declare function forecastExponentialSmoothing(metric: MetricName, samples: MetricSample[], horizonMs: number, alpha?: number, beta?: number): ForecastResult;
+/**
+ * Hour-of-week seasonal multiplier based on historical samples.
+ */
+export declare function forecastSeasonalPattern(metric: MetricName, samples: MetricSample[], horizonMs: number): ForecastResult;
+export declare function combineForecasts(forecasts: ForecastResult[]): ForecastResult | null;
+export declare function runForecastModel(model: ForecastModel, metric: MetricName, samples: MetricSample[], horizonMs: number): ForecastResult;
+//# sourceMappingURL=forecast-engine.d.ts.map

package/dist/forecast/forecast-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forecast-engine.d.ts","sourceRoot":"","sources":["../../src/forecast/forecast-engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEnF;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,YAAY,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,KAAK,SAAO,EACZ,IAAI,SAAO,GACV,cAAc,CA+ChB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,YAAY,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,cAAc,CAgChB;AAMD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,cAAc,GAAG,IAAI,CAkBnF;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,YAAY,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,cAAc,CAgBhB"}

package/dist/forecast/forecast-engine.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forecastExponentialSmoothing = forecastExponentialSmoothing;
+exports.forecastSeasonalPattern = forecastSeasonalPattern;
+exports.combineForecasts = combineForecasts;
+exports.runForecastModel = runForecastModel;
+/**
+ * Holt's linear exponential smoothing for short-horizon demand forecasting.
+ */
+function forecastExponentialSmoothing(metric, samples, horizonMs, alpha = 0.35, beta = 0.15) {
+    if (samples.length < 2) {
+        const latest = samples[samples.length - 1]?.value ?? 0;
+        return {
+            metric,
+            predictedValue: latest,
+            confidence: 0.3,
+            horizonMs,
+            model: 'exponential-smoothing',
+            at: Date.now(),
+        };
+    }
+    const sorted = [...samples].sort((a, b) => a.timestamp - b.timestamp);
+    let level = sorted[0].value;
+    let trend = sorted[1].value - sorted[0].value;
+    for (let i = 1; i < sorted.length; i++) {
+        const value = sorted[i].value;
+        const prevLevel = level;
+        level = alpha * value + (1 - alpha) * (level + trend);
+        trend = beta * (level - prevLevel) + (1 - beta) * trend;
+    }
+    const last = sorted[sorted.length - 1];
+    const dt = Math.max(1, last.timestamp - sorted[0].timestamp);
+    const steps = Math.max(1, horizonMs / (dt / Math.max(1, sorted.length - 1)));
+    const predictedValue = Math.max(0, level + trend * steps);
+    const residuals = sorted.slice(1).map((sample, index) => {
+        const expected = level;
+        return Math.abs(sample.value - expected);
+    });
+    const avgResidual = residuals.length === 0
+        ? 0
+        : residuals.reduce((sum, value) => sum + value, 0) / residuals.length;
+    const confidence = clampConfidence(1 - avgResidual / Math.max(1, level));
+    return {
+        metric,
+        predictedValue,
+        confidence,
+        horizonMs,
+        model: 'exponential-smoothing',
+        at: Date.now(),
+    };
+}
+/**
+ * Hour-of-week seasonal multiplier based on historical samples.
+ */
+function forecastSeasonalPattern(metric, samples, horizonMs) {
+    const now = Date.now();
+    const targetTime = now + horizonMs;
+    const targetHour = new Date(targetTime).getUTCHours();
+    const targetDow = new Date(targetTime).getUTCDay();
+    const buckets = new Map();
+    for (const sample of samples) {
+        const date = new Date(sample.timestamp);
+        const key = `${date.getUTCDay()}-${date.getUTCHours()}`;
+        const bucket = buckets.get(key) ?? [];
+        bucket.push(sample.value);
+        buckets.set(key, bucket);
+    }
+    const key = `${targetDow}-${targetHour}`;
+    const bucketValues = buckets.get(key) ?? samples.map((sample) => sample.value);
+    const predictedValue = bucketValues.reduce((sum, value) => sum + value, 0) / Math.max(1, bucketValues.length);
+    const globalAvg = samples.reduce((sum, sample) => sum + sample.value, 0) / Math.max(1, samples.length);
+    const confidence = clampConfidence(bucketValues.length / Math.max(3, samples.length / 24));
+    return {
+        metric,
+        predictedValue: predictedValue || globalAvg,
+        confidence,
+        horizonMs,
+        model: 'seasonal-pattern',
+        at: Date.now(),
+    };
+}
+function clampConfidence(value) {
+    return Math.min(1, Math.max(0, value));
+}
+function combineForecasts(forecasts) {
+    if (forecasts.length === 0) {
+        return null;
+    }
+    const totalWeight = forecasts.reduce((sum, forecast) => sum + forecast.confidence, 0) || 1;
+    const predictedValue = forecasts.reduce((sum, forecast) => sum + forecast.predictedValue * forecast.confidence, 0) /
+        totalWeight;
+    const confidence = forecasts.reduce((sum, forecast) => sum + forecast.confidence, 0) / forecasts.length;
+    return {
+        ...forecasts[0],
+        predictedValue,
+        confidence,
+        model: 'time-series-forecast',
+    };
+}
+function runForecastModel(model, metric, samples, horizonMs) {
+    switch (model) {
+        case 'seasonal-pattern':
+            return forecastSeasonalPattern(metric, samples, horizonMs);
+        case 'time-series-forecast':
+            return (combineForecasts([
+                forecastExponentialSmoothing(metric, samples, horizonMs),
+                forecastSeasonalPattern(metric, samples, horizonMs),
+            ]) ?? forecastExponentialSmoothing(metric, samples, horizonMs));
+        case 'exponential-smoothing':
+        case 'ai':
+        default:
+            return forecastExponentialSmoothing(metric, samples, horizonMs);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @hazeljs/predictive-scaling
+ * Predictive auto-scaling for HazelJS microservices
+ */
+export * from './types';
+export { MetricsStore } from './metrics/metrics-store';
+export { parseDuration, clamp } from './utils/duration';
+export { forecastExponentialSmoothing, forecastSeasonalPattern, combineForecasts, runForecastModel, } from './forecast/forecast-engine';
+export { ForecastEngine, createAIForecastProvider, AILlmForecastClient, } from './forecast/ai-forecast-provider';
+export { calculateTargetReplicas, decideScaling } from './scaling/replica-calculator';
+export { PredictiveScaler, createPredictiveScaler } from './scaling/predictive-scaler';
+export { EventScalingRegistry, calculateEventBoostReplicas, RegisteredScaleEvent, } from './events/event-scaling-registry';
+export { PredictiveScaling, ScalePredict, ScaleOnEvent, getPredictiveScaler, startPredictiveScaling, stopPredictiveScaling, emitScalingEvent, } from './decorators';
+export { adaptSelfHealingScalingClient, InMemoryScalingClient } from './integrations/self-healing';
+export { PrometheusMetricsCollector, PrometheusQueryConfig, PrometheusQueryResult, createPrometheusMetricsCollector, } from './metrics/prometheus-collector';
+export { attachPrometheusCollector } from './integrations/prometheus';
+export { createOperationsStack, OperationsStack, OperationsStackOptions, } from './integrations/operations-stack';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAEvF,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEnG,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,qBAAqB,EACrB,gCAAgC,GACjC,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,sBAAsB,GACvB,MAAM,iCAAiC,CAAC"}

package/dist/index.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * @hazeljs/predictive-scaling
+ * Predictive auto-scaling for HazelJS microservices
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOperationsStack = exports.attachPrometheusCollector = exports.createPrometheusMetricsCollector = exports.PrometheusMetricsCollector = exports.InMemoryScalingClient = exports.adaptSelfHealingScalingClient = exports.emitScalingEvent = exports.stopPredictiveScaling = exports.startPredictiveScaling = exports.getPredictiveScaler = exports.ScaleOnEvent = exports.ScalePredict = exports.PredictiveScaling = exports.calculateEventBoostReplicas = exports.EventScalingRegistry = exports.createPredictiveScaler = exports.PredictiveScaler = exports.decideScaling = exports.calculateTargetReplicas = exports.createAIForecastProvider = exports.ForecastEngine = exports.runForecastModel = exports.combineForecasts = exports.forecastSeasonalPattern = exports.forecastExponentialSmoothing = exports.clamp = exports.parseDuration = exports.MetricsStore = void 0;
+__exportStar(require("./types"), exports);
+var metrics_store_1 = require("./metrics/metrics-store");
+Object.defineProperty(exports, "MetricsStore", { enumerable: true, get: function () { return metrics_store_1.MetricsStore; } });
+var duration_1 = require("./utils/duration");
+Object.defineProperty(exports, "parseDuration", { enumerable: true, get: function () { return duration_1.parseDuration; } });
+Object.defineProperty(exports, "clamp", { enumerable: true, get: function () { return duration_1.clamp; } });
+var forecast_engine_1 = require("./forecast/forecast-engine");
+Object.defineProperty(exports, "forecastExponentialSmoothing", { enumerable: true, get: function () { return forecast_engine_1.forecastExponentialSmoothing; } });
+Object.defineProperty(exports, "forecastSeasonalPattern", { enumerable: true, get: function () { return forecast_engine_1.forecastSeasonalPattern; } });
+Object.defineProperty(exports, "combineForecasts", { enumerable: true, get: function () { return forecast_engine_1.combineForecasts; } });
+Object.defineProperty(exports, "runForecastModel", { enumerable: true, get: function () { return forecast_engine_1.runForecastModel; } });
+var ai_forecast_provider_1 = require("./forecast/ai-forecast-provider");
+Object.defineProperty(exports, "ForecastEngine", { enumerable: true, get: function () { return ai_forecast_provider_1.ForecastEngine; } });
+Object.defineProperty(exports, "createAIForecastProvider", { enumerable: true, get: function () { return ai_forecast_provider_1.createAIForecastProvider; } });
+var replica_calculator_1 = require("./scaling/replica-calculator");
+Object.defineProperty(exports, "calculateTargetReplicas", { enumerable: true, get: function () { return replica_calculator_1.calculateTargetReplicas; } });
+Object.defineProperty(exports, "decideScaling", { enumerable: true, get: function () { return replica_calculator_1.decideScaling; } });
+var predictive_scaler_1 = require("./scaling/predictive-scaler");
+Object.defineProperty(exports, "PredictiveScaler", { enumerable: true, get: function () { return predictive_scaler_1.PredictiveScaler; } });
+Object.defineProperty(exports, "createPredictiveScaler", { enumerable: true, get: function () { return predictive_scaler_1.createPredictiveScaler; } });
+var event_scaling_registry_1 = require("./events/event-scaling-registry");
+Object.defineProperty(exports, "EventScalingRegistry", { enumerable: true, get: function () { return event_scaling_registry_1.EventScalingRegistry; } });
+Object.defineProperty(exports, "calculateEventBoostReplicas", { enumerable: true, get: function () { return event_scaling_registry_1.calculateEventBoostReplicas; } });
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "PredictiveScaling", { enumerable: true, get: function () { return decorators_1.PredictiveScaling; } });
+Object.defineProperty(exports, "ScalePredict", { enumerable: true, get: function () { return decorators_1.ScalePredict; } });
+Object.defineProperty(exports, "ScaleOnEvent", { enumerable: true, get: function () { return decorators_1.ScaleOnEvent; } });
+Object.defineProperty(exports, "getPredictiveScaler", { enumerable: true, get: function () { return decorators_1.getPredictiveScaler; } });
+Object.defineProperty(exports, "startPredictiveScaling", { enumerable: true, get: function () { return decorators_1.startPredictiveScaling; } });
+Object.defineProperty(exports, "stopPredictiveScaling", { enumerable: true, get: function () { return decorators_1.stopPredictiveScaling; } });
+Object.defineProperty(exports, "emitScalingEvent", { enumerable: true, get: function () { return decorators_1.emitScalingEvent; } });
+var self_healing_1 = require("./integrations/self-healing");
+Object.defineProperty(exports, "adaptSelfHealingScalingClient", { enumerable: true, get: function () { return self_healing_1.adaptSelfHealingScalingClient; } });
+Object.defineProperty(exports, "InMemoryScalingClient", { enumerable: true, get: function () { return self_healing_1.InMemoryScalingClient; } });
+var prometheus_collector_1 = require("./metrics/prometheus-collector");
+Object.defineProperty(exports, "PrometheusMetricsCollector", { enumerable: true, get: function () { return prometheus_collector_1.PrometheusMetricsCollector; } });
+Object.defineProperty(exports, "createPrometheusMetricsCollector", { enumerable: true, get: function () { return prometheus_collector_1.createPrometheusMetricsCollector; } });
+var prometheus_1 = require("./integrations/prometheus");
+Object.defineProperty(exports, "attachPrometheusCollector", { enumerable: true, get: function () { return prometheus_1.attachPrometheusCollector; } });
+var operations_stack_1 = require("./integrations/operations-stack");
+Object.defineProperty(exports, "createOperationsStack", { enumerable: true, get: function () { return operations_stack_1.createOperationsStack; } });

package/dist/integrations/operations-stack.d.ts

@@ -0,0 +1,22 @@
+import { HealingCoordinator } from '@hazeljs/self-healing';
+import type { SelfHealingModuleOptions } from '@hazeljs/self-healing';
+import { PredictiveScaler } from '../scaling/predictive-scaler';
+import { PrometheusMetricsCollector, PrometheusQueryConfig } from '../metrics/prometheus-collector';
+import { PredictiveScalingOptions } from '../types';
+export interface OperationsStackOptions {
+    healing?: SelfHealingModuleOptions;
+    scaling: PredictiveScalingOptions;
+    prometheus?: PrometheusQueryConfig;
+}
+export interface OperationsStack {
+    healing: HealingCoordinator;
+    scaler: PredictiveScaler;
+    prometheus?: PrometheusMetricsCollector;
+    start(): void;
+    stop(): void;
+}
+/**
+ * Production stack: reactive self-healing + proactive predictive scaling (+ optional Prometheus feed).
+ */
+export declare function createOperationsStack(options: OperationsStackOptions): OperationsStack;
+//# sourceMappingURL=operations-stack.d.ts.map

package/dist/integrations/operations-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-stack.d.ts","sourceRoot":"","sources":["../../src/integrations/operations-stack.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACrF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,OAAO,EAA0B,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACxF,OAAO,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,OAAO,EAAE,wBAAwB,CAAC;IAClC,UAAU,CAAC,EAAE,qBAAqB,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,kBAAkB,CAAC;IAC5B,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,CAAC,EAAE,0BAA0B,CAAC;IACxC,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CAwCtF"}

package/dist/integrations/operations-stack.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOperationsStack = createOperationsStack;
+const self_healing_1 = require("@hazeljs/self-healing");
+const prometheus_1 = require("./prometheus");
+const self_healing_2 = require("./self-healing");
+const predictive_scaler_1 = require("../scaling/predictive-scaler");
+/**
+ * Production stack: reactive self-healing + proactive predictive scaling (+ optional Prometheus feed).
+ */
+function createOperationsStack(options) {
+    const healing = (0, self_healing_1.createHealingCoordinator)(options.healing ?? {});
+    const scalingClient = options.scaling.hpa.client ??
+        (options.healing?.kubernetes?.hpa?.client
+            ? (0, self_healing_2.adaptSelfHealingScalingClient)(options.healing.kubernetes.hpa.client)
+            : undefined);
+    if (!scalingClient) {
+        throw new Error('Operations stack requires scaling.hpa.client or healing.kubernetes.hpa.client');
+    }
+    const scaler = (0, predictive_scaler_1.createPredictiveScaler)({
+        ...options.scaling,
+        hpa: {
+            ...options.scaling.hpa,
+            client: scalingClient,
+        },
+    });
+    const prometheus = options.prometheus
+        ? (0, prometheus_1.attachPrometheusCollector)(scaler, options.prometheus)
+        : undefined;
+    return {
+        healing,
+        scaler,
+        prometheus,
+        start() {
+            scaler.start();
+            prometheus?.start();
+        },
+        stop() {
+            scaler.stop();
+            prometheus?.stop();
+        },
+    };
+}

package/dist/integrations/prometheus.d.ts

@@ -0,0 +1,7 @@
+import { PrometheusMetricsCollector, PrometheusQueryConfig } from '../metrics/prometheus-collector';
+import { PredictiveScaler } from '../scaling/predictive-scaler';
+/**
+ * Attach Prometheus polling to a predictive scaler metrics store.
+ */
+export declare function attachPrometheusCollector(scaler: PredictiveScaler, config: PrometheusQueryConfig): PrometheusMetricsCollector;
+//# sourceMappingURL=prometheus.d.ts.map

package/dist/integrations/prometheus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.d.ts","sourceRoot":"","sources":["../../src/integrations/prometheus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACpG,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,qBAAqB,GAC5B,0BAA0B,CAI5B"}

package/dist/integrations/prometheus.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachPrometheusCollector = attachPrometheusCollector;
+const prometheus_collector_1 = require("../metrics/prometheus-collector");
+/**
+ * Attach Prometheus polling to a predictive scaler metrics store.
+ */
+function attachPrometheusCollector(scaler, config) {
+    return new prometheus_collector_1.PrometheusMetricsCollector(config, (sample) => {
+        scaler.recordMetric(sample.metric, sample.value, sample.timestamp);
+    });
+}

package/dist/integrations/self-healing.d.ts

@@ -0,0 +1,21 @@
+import { KubernetesScalingClient } from '../types';
+type SelfHealingScalingClient = {
+    getHpaMinReplicas(hpa: string, namespace: string): Promise<number>;
+    setHpaMinReplicas(hpa: string, namespace: string, minReplicas: number): Promise<void>;
+};
+/**
+ * Bridge scaling clients exported by @hazeljs/self-healing.
+ */
+export declare function adaptSelfHealingScalingClient(client: SelfHealingScalingClient): KubernetesScalingClient;
+export declare class InMemoryScalingClient implements KubernetesScalingClient {
+    readonly updates: Array<{
+        hpa: string;
+        namespace: string;
+        minReplicas: number;
+    }>;
+    private readonly state;
+    getHpaMinReplicas(hpa: string, namespace: string): Promise<number>;
+    setHpaMinReplicas(hpa: string, namespace: string, minReplicas: number): Promise<void>;
+}
+export {};
+//# sourceMappingURL=self-healing.d.ts.map

package/dist/integrations/self-healing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-healing.d.ts","sourceRoot":"","sources":["../../src/integrations/self-healing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAEnD,KAAK,wBAAwB,GAAG;IAC9B,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACnE,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvF,CAAC;AAEF;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,wBAAwB,GAC/B,uBAAuB,CAMzB;AAED,qBAAa,qBAAsB,YAAW,uBAAuB;IACnE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IACtF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IAE7C,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIlE,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAI5F"}

package/dist/integrations/self-healing.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryScalingClient = void 0;
+exports.adaptSelfHealingScalingClient = adaptSelfHealingScalingClient;
+/**
+ * Bridge scaling clients exported by @hazeljs/self-healing.
+ */
+function adaptSelfHealingScalingClient(client) {
+    return {
+        getHpaMinReplicas: (hpa, namespace) => client.getHpaMinReplicas(hpa, namespace),
+        setHpaMinReplicas: (hpa, namespace, minReplicas) => client.setHpaMinReplicas(hpa, namespace, minReplicas),
+    };
+}
+class InMemoryScalingClient {
+    constructor() {
+        this.updates = [];
+        this.state = new Map();
+    }
+    async getHpaMinReplicas(hpa, namespace) {
+        return this.state.get(`${namespace}/${hpa}`) ?? 2;
+    }
+    async setHpaMinReplicas(hpa, namespace, minReplicas) {
+        this.state.set(`${namespace}/${hpa}`, minReplicas);
+        this.updates.push({ hpa, namespace, minReplicas });
+    }
+}
+exports.InMemoryScalingClient = InMemoryScalingClient;

package/dist/metrics/metrics-store.d.ts

@@ -0,0 +1,15 @@
+import { MetricName, MetricSample } from '../types';
+/**
+ * Ring-buffer time series store per metric.
+ */
+export declare class MetricsStore {
+    private readonly maxSamples;
+    private readonly series;
+    constructor(maxSamples?: number);
+    record(metric: MetricName, value: number, timestamp?: number): MetricSample;
+    getSamples(metric: MetricName): MetricSample[];
+    getLatest(metric: MetricName): MetricSample | undefined;
+    metrics(): MetricName[];
+    clear(metric?: MetricName): void;
+}
+//# sourceMappingURL=metrics-store.d.ts.map

package/dist/metrics/metrics-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-store.d.ts","sourceRoot":"","sources":["../../src/metrics/metrics-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEpD;;GAEG;AACH,qBAAa,YAAY;IAGX,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;gBAEnC,UAAU,SAAM;IAE7C,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,SAAa,GAAG,YAAY;IAa/E,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,YAAY,EAAE;IAI9C,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,YAAY,GAAG,SAAS;IAKvD,OAAO,IAAI,UAAU,EAAE;IAIvB,KAAK,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI;CAOjC"}

package/dist/metrics/metrics-store.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsStore = void 0;
+/**
+ * Ring-buffer time series store per metric.
+ */
+class MetricsStore {
+    constructor(maxSamples = 500) {
+        this.maxSamples = maxSamples;
+        this.series = new Map();
+    }
+    record(metric, value, timestamp = Date.now()) {
+        const sample = { metric, value, timestamp };
+        const history = this.series.get(metric) ?? [];
+        history.push(sample);
+        if (history.length > this.maxSamples) {
+            history.shift();
+        }
+        this.series.set(metric, history);
+        return sample;
+    }
+    getSamples(metric) {
+        return [...(this.series.get(metric) ?? [])];
+    }
+    getLatest(metric) {
+        const history = this.series.get(metric);
+        return history?.[history.length - 1];
+    }
+    metrics() {
+        return [...this.series.keys()];
+    }
+    clear(metric) {
+        if (metric) {
+            this.series.delete(metric);
+            return;
+        }
+        this.series.clear();
+    }
+}
+exports.MetricsStore = MetricsStore;

package/dist/metrics/prometheus-collector.d.ts

@@ -0,0 +1,30 @@
+import { MetricName } from '../types';
+export interface PrometheusQueryConfig {
+    /** Prometheus server base URL, e.g. https://prometheus.example.com */
+    baseUrl: string;
+    /** PromQL per predictive-scaling metric name */
+    queries: Partial<Record<MetricName, string>>;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export interface PrometheusQueryResult {
+    metric: MetricName;
+    value: number;
+    timestamp: number;
+}
+/**
+ * Polls Prometheus and ingests scalar query results into a callback.
+ */
+export declare class PrometheusMetricsCollector {
+    private readonly config;
+    private readonly onSample;
+    private interval;
+    constructor(config: PrometheusQueryConfig, onSample: (sample: PrometheusQueryResult) => void);
+    pollOnce(): Promise<PrometheusQueryResult[]>;
+    start(): void;
+    stop(): void;
+    private queryMetric;
+}
+export declare function createPrometheusMetricsCollector(config: PrometheusQueryConfig, onSample: (sample: PrometheusQueryResult) => void): PrometheusMetricsCollector;
+//# sourceMappingURL=prometheus-collector.d.ts.map

package/dist/metrics/prometheus-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus-collector.d.ts","sourceRoot":"","sources":["../../src/metrics/prometheus-collector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,WAAW,qBAAqB;IACpC,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAWD;;GAEG;AACH,qBAAa,0BAA0B;IAInC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAA+C;gBAG5C,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI;IAG9D,QAAQ,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAkBlD,KAAK,IAAI,IAAI;IAiBb,IAAI,IAAI,IAAI;YAOE,WAAW;CAwC1B;AAED,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,GAChD,0BAA0B,CAE5B"}