@hazeljs/predictive-scaling 2.0.5

package/README.md

@@ -0,0 +1,172 @@
+# @hazeljs/predictive-scaling
+
+**Scale before the spike. Not after.**
+
+Forecast traffic ~30 minutes ahead, raise Kubernetes HPA `minReplicas` proactively, and boost on business events.
+
+Use [`@hazeljs/self-healing`](https://hazeljs.ai/docs/packages/self-healing) for **reactive** recovery (`hpa-boost` after latency degrades). This package is **proactive**.
+
+[![npm version](https://img.shields.io/npm/v/@hazeljs/predictive-scaling.svg)](https://www.npmjs.com/package/@hazeljs/predictive-scaling)
+[![npm downloads](https://img.shields.io/npm/dm/@hazeljs/predictive-scaling)](https://www.npmjs.com/package/@hazeljs/predictive-scaling)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Features
+
+- 📈 **Time-series forecast** - Exponential smoothing + seasonal hour-of-week patterns
+- ☸️ **Proactive HPA** - Raise `minReplicas` before predicted spikes
+- 💰 **Cost optimization** - Confidence thresholds and gradual scale-down
+- 🎉 **Event-driven boosts** - `black-friday`, `product-launch`, custom events
+- 🎨 **Decorator API** - `@PredictiveScaling`, `@ScalePredict`, `@ScaleOnEvent`
+- 🤖 **Optional AI forecasts** - `createAIForecastProvider()` hook for `@hazeljs/ai`
+- 📊 **Prometheus ingest** - Poll real cluster metrics into the forecast
+- 🔗 **Self-healing bridge** - `adaptSelfHealingScalingClient()` + `createOperationsStack()`
+
+## Installation
+
+```bash
+npm install @hazeljs/predictive-scaling @hazeljs/core
+```
+
+### Optional Dependencies
+
+```bash
+npm install @hazeljs/self-healing @hazeljs/ai
+```
+
+## Quick Start
+
+```typescript
+import {
+  PredictiveScaling,
+  ScalePredict,
+  ScaleOnEvent,
+  createPredictiveScaler,
+  InMemoryScalingClient,
+  adaptSelfHealingScalingClient,
+} from '@hazeljs/predictive-scaling';
+import { InMemoryKubernetesScalingClient } from '@hazeljs/self-healing';
+
+@PredictiveScaling({
+  model: 'time-series-forecast',
+  metrics: ['requests', 'latency'],
+  horizon: '30m',
+  confidence: 0.85,
+  costOptimization: true,
+  hpa: {
+    name: 'video-hpa',
+    namespace: 'prod',
+    client: adaptSelfHealingScalingClient(new InMemoryKubernetesScalingClient()),
+    maxReplicas: 100,
+  },
+})
+@ScaleOnEvent({
+  events: ['product-launch', 'black-friday'],
+  maxScale: 100,
+  scaleFactor: 2,
+})
+export class AppModule {}
+
+export class VideoStreamingService {
+  @ScalePredict({
+    triggers: ['weekend-pattern', 'viral-content'],
+    scaleUp: { before: '15m', factor: 2 },
+  })
+  async streamVideo() {
+    // Demand signals recorded automatically
+  }
+}
+```
+
+## Programmatic API
+
+```typescript
+const scaler = createPredictiveScaler({
+  horizon: '30m',
+  metrics: ['requests'],
+  hpa: { name: 'api-hpa', namespace: 'prod', client: new InMemoryScalingClient() },
+});
+
+scaler.recordMetric('requests', 420);
+scaler.start(); // poll + forecast + apply every 60s
+
+await scaler.triggerEvent('black-friday');
+```
+
+## Prometheus Ingestion
+
+Feed real cluster metrics into forecasts:
+
+```typescript
+import { createPredictiveScaler, attachPrometheusCollector } from '@hazeljs/predictive-scaling';
+
+const scaler = createPredictiveScaler({
+  metrics: ['requests', 'latency', 'cpu'],
+  hpa: { name: 'api-hpa', namespace: 'prod', client },
+});
+
+const prometheus = attachPrometheusCollector(scaler, {
+  baseUrl: process.env.PROMETHEUS_URL ?? 'http://localhost:9090',
+  pollIntervalMs: 60_000,
+  queries: {
+    requests: 'sum(rate(http_requests_total{service="api"}[5m]))',
+    latency:
+      'histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{service="api"}[5m])) by (le))',
+    cpu: 'avg(rate(container_cpu_usage_seconds_total{pod=~"api-.*"}[5m]))',
+  },
+});
+
+scaler.start();
+prometheus.start();
+```
+
+## Combined Ops Stack
+
+Wire this package with `@hazeljs/self-healing`:
+
+```typescript
+import { createOperationsStack } from '@hazeljs/predictive-scaling';
+import { InMemoryKubernetesScalingClient } from '@hazeljs/self-healing';
+
+const client = new InMemoryKubernetesScalingClient();
+
+const ops = createOperationsStack({
+  healing: {
+    strategies: ['hpa-boost', 'pod-restart', 'config-rollback'],
+    kubernetes: { deployment: 'payments-api', hpa: { name: 'payments-hpa', client } },
+  },
+  scaling: {
+    horizon: '30m',
+    metrics: ['requests', 'latency'],
+    hpa: { name: 'payments-hpa', client },
+  },
+  prometheus: {
+    baseUrl: 'http://prometheus.monitoring:9090',
+    queries: { requests: 'sum(rate(http_requests_total[5m]))' },
+  },
+});
+
+ops.start();
+```
+
+See `examples/production-ops-stack.ts` for a full production wiring template.
+
+## Testing
+
+```bash
+npm test
+```
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details.
+
+## License
+
+Apache 2.0 © [HazelJS](https://hazeljs.ai)
+
+## Links
+
+- [Documentation](https://hazeljs.ai/docs/packages/predictive-scaling)
+- [GitHub](https://github.com/hazel-js/hazeljs)
+- [Issues](https://github.com/hazel-js/hazeljs/issues)
+- [Discord](https://discord.gg/PxNBPzvQk7)

package/dist/__tests__/ai-forecast.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ai-forecast.test.d.ts.map

package/dist/__tests__/ai-forecast.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-forecast.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/ai-forecast.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/ai-forecast.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_forecast_provider_1 = require("../forecast/ai-forecast-provider");
+describe('AI forecast provider', () => {
+    it('parses LLM JSON forecast', async () => {
+        const provider = (0, ai_forecast_provider_1.createAIForecastProvider)({
+            complete: jest
+                .fn()
+                .mockResolvedValue(JSON.stringify({ predictedValue: 420, confidence: 0.88 })),
+        });
+        const result = await provider.forecast('requests', [{ metric: 'requests', value: 100, timestamp: Date.now() }], 30 * 60000);
+        expect(result?.predictedValue).toBe(420);
+        expect(result?.model).toBe('ai');
+    });
+});

package/dist/__tests__/decorators.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=decorators.test.d.ts.map

package/dist/__tests__/decorators.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/decorators.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/decorators.test.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const decorators_1 = require("../decorators");
+const self_healing_1 = require("../integrations/self-healing");
+const event_scaling_registry_1 = require("../events/event-scaling-registry");
+describe('Predictive scaling decorators', () => {
+    afterEach(() => {
+        event_scaling_registry_1.EventScalingRegistry.reset();
+    });
+    it('records metrics via @ScalePredict', async () => {
+        const client = new self_healing_1.InMemoryScalingClient();
+        let StreamingService = class StreamingService {
+            async streamVideo() {
+                await new Promise((resolve) => setTimeout(resolve, 5));
+                return 'ok';
+            }
+        };
+        __decorate([
+            (0, decorators_1.ScalePredict)({ triggers: ['viral-content'] }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], StreamingService.prototype, "streamVideo", null);
+        StreamingService = __decorate([
+            (0, decorators_1.PredictiveScaling)({
+                metrics: ['requests', 'latency'],
+                hpa: { name: 'svc-hpa', namespace: 'default', client },
+            }),
+            (0, decorators_1.ScaleOnEvent)({ events: ['launch'], maxScale: 10 })
+        ], StreamingService);
+        const service = new StreamingService();
+        await service.streamVideo();
+        const scaler = (0, decorators_1.getPredictiveScaler)(StreamingService);
+        expect(scaler).toBeDefined();
+        expect(scaler.getMetricsStore().getSamples('requests').length).toBeGreaterThan(0);
+        expect(scaler.getMetricsStore().getSamples('latency').length).toBeGreaterThan(0);
+    });
+});

package/dist/__tests__/duration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=duration.test.d.ts.map

package/dist/__tests__/duration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/duration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/duration.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const duration_1 = require("../utils/duration");
+describe('parseDuration', () => {
+    it('parses minute and hour durations', () => {
+        expect((0, duration_1.parseDuration)('30m')).toBe(30 * 60000);
+        expect((0, duration_1.parseDuration)('1h')).toBe(3600000);
+        expect((0, duration_1.parseDuration)(5000)).toBe(5000);
+    });
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=forecast-engine.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"forecast-engine.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/forecast-engine.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/forecast-engine.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const forecast_engine_1 = require("../forecast/forecast-engine");
+describe('Forecast engine', () => {
+    it('forecasts upward trend', () => {
+        const base = Date.now() - 10 * 60000;
+        const samples = Array.from({ length: 10 }, (_, index) => ({
+            metric: 'requests',
+            value: 100 + index * 20,
+            timestamp: base + index * 60000,
+        }));
+        const forecast = (0, forecast_engine_1.forecastExponentialSmoothing)('requests', samples, 30 * 60000);
+        expect(forecast.predictedValue).toBeGreaterThan(250);
+        expect(forecast.confidence).toBeGreaterThan(0);
+    });
+    it('uses seasonal buckets', () => {
+        const now = Date.now();
+        const samples = [
+            { metric: 'requests', value: 200, timestamp: now - 7 * 24 * 60 * 60000 },
+            { metric: 'requests', value: 220, timestamp: now - 6 * 24 * 60 * 60000 },
+        ];
+        const forecast = (0, forecast_engine_1.forecastSeasonalPattern)('requests', samples, 60000);
+        expect(forecast.predictedValue).toBeGreaterThan(0);
+    });
+});

package/dist/__tests__/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/__tests__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/index.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/index.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('package exports', () => {
+    it('exposes public API', () => {
+        expect((0, index_1.parseDuration)('15m')).toBe(900000);
+        expect(index_1.createPredictiveScaler).toBeDefined();
+        expect(index_1.createAIForecastProvider).toBeDefined();
+        expect(index_1.adaptSelfHealingScalingClient).toBeDefined();
+        const client = new index_1.InMemoryScalingClient();
+        const adapted = (0, index_1.adaptSelfHealingScalingClient)(client);
+        expect(adapted.getHpaMinReplicas).toBeDefined();
+        const decision = (0, index_1.decideScaling)({
+            currentReplicas: 1,
+            predictedLoad: 10,
+            capacityPerReplica: 100,
+            maxReplicas: 5,
+            minReplicas: 1,
+            confidence: 0.9,
+        });
+        expect(decision.action).toBe('hold');
+    });
+});

package/dist/__tests__/operations-stack.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=operations-stack.test.d.ts.map

package/dist/__tests__/operations-stack.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-stack.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/operations-stack.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/operations-stack.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operations_stack_1 = require("../integrations/operations-stack");
+const self_healing_1 = require("../integrations/self-healing");
+describe('createOperationsStack', () => {
+    it('wires healing and predictive scaler with shared scaling client', () => {
+        const client = new self_healing_1.InMemoryScalingClient();
+        const stack = (0, operations_stack_1.createOperationsStack)({
+            healing: {
+                strategies: ['hpa-boost', 'pod-restart'],
+                kubernetes: {
+                    deployment: 'orders-api',
+                    namespace: 'prod',
+                    hpa: { name: 'orders-hpa', client, boostMinReplicas: 4 },
+                },
+            },
+            scaling: {
+                metrics: ['requests'],
+                hpa: { name: 'orders-hpa', namespace: 'prod', client },
+            },
+        });
+        expect(stack.healing).toBeDefined();
+        expect(stack.scaler).toBeDefined();
+        expect(stack.prometheus).toBeUndefined();
+        stack.start();
+        stack.stop();
+    });
+    it('throws when no scaling client is provided', () => {
+        expect(() => (0, operations_stack_1.createOperationsStack)({
+            scaling: {
+                hpa: { name: 'missing-client-hpa' },
+            },
+        })).toThrow(/requires scaling\.hpa\.client/);
+    });
+});

package/dist/__tests__/predictive-scaler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=predictive-scaler.test.d.ts.map

package/dist/__tests__/predictive-scaler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictive-scaler.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/predictive-scaler.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/predictive-scaler.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const predictive_scaler_1 = require("../scaling/predictive-scaler");
+const self_healing_1 = require("../integrations/self-healing");
+const event_scaling_registry_1 = require("../events/event-scaling-registry");
+describe('PredictiveScaler', () => {
+    afterEach(() => {
+        event_scaling_registry_1.EventScalingRegistry.reset();
+    });
+    it('scales HPA up on high predicted demand', async () => {
+        const client = new self_healing_1.InMemoryScalingClient();
+        await client.setHpaMinReplicas('api-hpa', 'prod', 2);
+        const scaler = (0, predictive_scaler_1.createPredictiveScaler)({
+            metrics: ['requests'],
+            horizon: '30m',
+            confidence: 0.5,
+            capacityPerReplica: 50,
+            pollIntervalMs: 60000,
+            hpa: { name: 'api-hpa', namespace: 'prod', client, maxReplicas: 20 },
+        });
+        const base = Date.now() - 30 * 60000;
+        for (let i = 0; i < 20; i++) {
+            scaler.recordMetric('requests', 80 + i * 15, base + i * 60000);
+        }
+        const event = await scaler.runCycle();
+        expect(['scale-up', 'no-op', 'hold']).toContain(event.type === 'no-op' ? 'no-op' : event.type);
+        if (event.type === 'scale-up') {
+            expect(event.toReplicas).toBeGreaterThan(event.fromReplicas);
+        }
+    });
+    it('boosts replicas on registered events', async () => {
+        const client = new self_healing_1.InMemoryScalingClient();
+        await client.setHpaMinReplicas('shop-hpa', 'prod', 3);
+        event_scaling_registry_1.EventScalingRegistry.register('EcommerceService', {
+            events: ['black-friday'],
+            maxScale: 50,
+            scaleFactor: 2,
+        });
+        const scaler = (0, predictive_scaler_1.createPredictiveScaler)({
+            hpa: { name: 'shop-hpa', namespace: 'prod', client },
+        });
+        const events = await scaler.triggerEvent('black-friday');
+        expect(events[0].toReplicas).toBe(6);
+        expect(client.updates.at(-1)?.minReplicas).toBe(6);
+    });
+});

package/dist/__tests__/prometheus-collector.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prometheus-collector.test.d.ts.map

package/dist/__tests__/prometheus-collector.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus-collector.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/prometheus-collector.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/prometheus-collector.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prometheus_collector_1 = require("../metrics/prometheus-collector");
+const prometheus_1 = require("../integrations/prometheus");
+const predictive_scaler_1 = require("../scaling/predictive-scaler");
+const self_healing_1 = require("../integrations/self-healing");
+describe('Prometheus metrics collector', () => {
+    it('queries Prometheus and emits samples', async () => {
+        const fetchImpl = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                status: 'success',
+                data: { result: [{ value: [1700000000, '42.5'] }] },
+            }),
+        });
+        const samples = [];
+        const collector = (0, prometheus_collector_1.createPrometheusMetricsCollector)({
+            baseUrl: 'http://prometheus:9090',
+            queries: { requests: 'sum(rate(http_requests_total[5m]))' },
+            fetchImpl,
+        }, (sample) => samples.push(sample.value));
+        await collector.pollOnce();
+        expect(fetchImpl).toHaveBeenCalledWith(expect.stringContaining('/api/v1/query?query='), expect.any(Object));
+        expect(samples).toEqual([42.5]);
+    });
+    it('feeds predictive scaler via attachPrometheusCollector', async () => {
+        const fetchImpl = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                status: 'success',
+                data: { result: [{ value: [1700000000, '100'] }] },
+            }),
+        });
+        const client = new self_healing_1.InMemoryScalingClient();
+        const scaler = (0, predictive_scaler_1.createPredictiveScaler)({
+            metrics: ['requests'],
+            hpa: { name: 'api-hpa', client },
+        });
+        const collector = (0, prometheus_1.attachPrometheusCollector)(scaler, {
+            baseUrl: 'http://prometheus:9090',
+            queries: { requests: 'sum(rate(http_requests_total[5m]))' },
+            fetchImpl,
+        });
+        await collector.pollOnce();
+        expect(scaler.getMetricsStore().getLatest('requests')?.value).toBe(100);
+    });
+});

package/dist/__tests__/replica-calculator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=replica-calculator.test.d.ts.map

package/dist/__tests__/replica-calculator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replica-calculator.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/replica-calculator.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/replica-calculator.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const replica_calculator_1 = require("../scaling/replica-calculator");
+describe('Replica calculator', () => {
+    it('scales up when predicted load exceeds headroom', () => {
+        const decision = (0, replica_calculator_1.decideScaling)({
+            currentReplicas: 2,
+            predictedLoad: 500,
+            capacityPerReplica: 100,
+            maxReplicas: 20,
+            minReplicas: 1,
+            confidence: 0.9,
+        }, { enabled: true, minConfidence: 0.7 });
+        expect(decision.action).toBe('scale-up');
+        expect(decision.targetReplicas).toBeGreaterThan(2);
+    });
+    it('holds when confidence is low', () => {
+        const decision = (0, replica_calculator_1.decideScaling)({
+            currentReplicas: 2,
+            predictedLoad: 500,
+            capacityPerReplica: 100,
+            maxReplicas: 20,
+            minReplicas: 1,
+            confidence: 0.4,
+        }, { enabled: true, minConfidence: 0.7 });
+        expect(decision.action).toBe('hold');
+    });
+});

package/dist/decorators/index.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import { PredictiveScaler } from '../scaling/predictive-scaler';
+import { PredictiveScalingOptions, ScaleOnEventOptions, ScalePredictOptions } from '../types';
+/**
+ * Module-level predictive scaling configuration.
+ */
+export declare function PredictiveScaling(options: PredictiveScalingOptions): ClassDecorator;
+export declare function getPredictiveScaler(constructor: Function): PredictiveScaler | undefined;
+/**
+ * Method-level hook to record demand signals for forecasting.
+ */
+export declare function ScalePredict(options?: ScalePredictOptions): MethodDecorator;
+/**
+ * Register event-driven scaling triggers on a service class.
+ */
+export declare function ScaleOnEvent(options: ScaleOnEventOptions): ClassDecorator;
+export declare function startPredictiveScaling(constructor: Function): void;
+export declare function stopPredictiveScaling(constructor: Function): void;
+export declare function emitScalingEvent(constructor: Function, eventName: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAAE,gBAAgB,EAA0B,MAAM,8BAA8B,CAAC;AACxF,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAQ9F;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,cAAc,CAQnF;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,QAAQ,GAAG,gBAAgB,GAAG,SAAS,CAIvF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,eAAe,CAgC/E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAIzE;AAED,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,QAAQ,GAAG,IAAI,CAElE;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,QAAQ,GAAG,IAAI,CAEjE;AAED,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK9F"}

package/dist/decorators/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictiveScaling = PredictiveScaling;
+exports.getPredictiveScaler = getPredictiveScaler;
+exports.ScalePredict = ScalePredict;
+exports.ScaleOnEvent = ScaleOnEvent;
+exports.startPredictiveScaling = startPredictiveScaling;
+exports.stopPredictiveScaling = stopPredictiveScaling;
+exports.emitScalingEvent = emitScalingEvent;
+require("reflect-metadata");
+const event_scaling_registry_1 = require("../events/event-scaling-registry");
+const predictive_scaler_1 = require("../scaling/predictive-scaler");
+const MODULE_SCALER_KEY = Symbol('hazeljs:predictive-scaling:scaler');
+const MODULE_OPTIONS_KEY = Symbol('hazeljs:predictive-scaling:module');
+const SCALE_PREDICT_KEY = Symbol('hazeljs:predictive-scaling:scale-predict');
+const globalRegistry = new Map();
+/**
+ * Module-level predictive scaling configuration.
+ */
+function PredictiveScaling(options) {
+    return function (constructor) {
+        const scope = constructor.name;
+        const scaler = (0, predictive_scaler_1.createPredictiveScaler)(options);
+        globalRegistry.set(scope, scaler);
+        Reflect.defineMetadata(MODULE_SCALER_KEY, scaler, constructor);
+        Reflect.defineMetadata(MODULE_OPTIONS_KEY, options, constructor);
+    };
+}
+function getPredictiveScaler(constructor) {
+    return (Reflect.getMetadata(MODULE_SCALER_KEY, constructor) ?? globalRegistry.get(constructor.name));
+}
+/**
+ * Method-level hook to record demand signals for forecasting.
+ */
+function ScalePredict(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const name = options.name ?? `${target.constructor.name}.${String(propertyKey)}`;
+        const predictions = Reflect.getMetadata(SCALE_PREDICT_KEY, target.constructor) ?? [];
+        predictions.push({ ...options, name });
+        Reflect.defineMetadata(SCALE_PREDICT_KEY, predictions, target.constructor);
+        descriptor.value = async function (...args) {
+            const scaler = globalRegistry.get(target.constructor.name);
+            const started = Date.now();
+            try {
+                const result = await originalMethod.apply(this, args);
+                if (scaler) {
+                    scaler.recordMetric('requests', 1);
+                    const duration = Date.now() - started;
+                    scaler.recordMetric('latency', duration);
+                }
+                return result;
+            }
+            catch (error) {
+                if (scaler) {
+                    scaler.recordMetric('requests', 1);
+                }
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+/**
+ * Register event-driven scaling triggers on a service class.
+ */
+function ScaleOnEvent(options) {
+    return function (constructor) {
+        event_scaling_registry_1.EventScalingRegistry.register(constructor.name, options);
+    };
+}
+function startPredictiveScaling(constructor) {
+    getPredictiveScaler(constructor)?.start();
+}
+function stopPredictiveScaling(constructor) {
+    getPredictiveScaler(constructor)?.stop();
+}
+async function emitScalingEvent(constructor, eventName) {
+    const scaler = getPredictiveScaler(constructor);
+    if (scaler) {
+        await scaler.triggerEvent(eventName);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ScaleOnEventOptions } from '../types';
+export interface RegisteredScaleEvent extends ScaleOnEventOptions {
+    scope: string;
+}
+/**
+ * Registry for event-driven predictive scaling triggers.
+ */
+export declare class EventScalingRegistry {
+    private static events;
+    static register(scope: string, options: ScaleOnEventOptions): void;
+    static get(scope: string): RegisteredScaleEvent[];
+    static findMatching(eventName: string): RegisteredScaleEvent[];
+    static reset(): void;
+}
+export declare function calculateEventBoostReplicas(currentReplicas: number, options: ScaleOnEventOptions): number;
+//# sourceMappingURL=event-scaling-registry.d.ts.map