@hazeljs/ml 0.2.0-alpha.1

package/dist/evaluation/metrics.service.test.js

@@ -0,0 +1,253 @@
+"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 });
+const model_registry_1 = require("../registry/model.registry");
+const predictor_service_1 = require("../inference/predictor.service");
+const metrics_service_1 = require("./metrics.service");
+const decorators_1 = require("../decorators");
+describe('MetricsService', () => {
+    let service;
+    beforeEach(() => {
+        service = new metrics_service_1.MetricsService();
+    });
+    it('records and retrieves evaluation', () => {
+        service.recordEvaluation({
+            modelName: 'model',
+            version: '1.0.0',
+            metrics: { accuracy: 0.95, loss: 0.05 },
+            evaluatedAt: new Date(),
+        });
+        const metrics = service.getMetrics('model', '1.0.0');
+        expect(metrics?.metrics.accuracy).toBe(0.95);
+    });
+    it('getMetrics returns latest when no version', () => {
+        service.recordEvaluation({
+            modelName: 'm',
+            version: '1',
+            metrics: { accuracy: 0.9 },
+            evaluatedAt: new Date(),
+        });
+        service.recordEvaluation({
+            modelName: 'm',
+            version: '2',
+            metrics: { accuracy: 0.95 },
+            evaluatedAt: new Date(),
+        });
+        const latest = service.getMetrics('m');
+        expect(latest?.version).toBe('2');
+        expect(latest?.metrics.accuracy).toBe(0.95);
+    });
+    it('getHistory returns all evaluations', () => {
+        service.recordEvaluation({
+            modelName: 'm',
+            version: '1',
+            metrics: {},
+            evaluatedAt: new Date(),
+        });
+        service.recordEvaluation({
+            modelName: 'm',
+            version: '2',
+            metrics: {},
+            evaluatedAt: new Date(),
+        });
+        expect(service.getHistory('m')).toHaveLength(2);
+    });
+    it('compareVersions returns winner by accuracy', () => {
+        service.recordEvaluation({
+            modelName: 'm',
+            version: 'a',
+            metrics: { accuracy: 0.9 },
+            evaluatedAt: new Date(),
+        });
+        service.recordEvaluation({
+            modelName: 'm',
+            version: 'b',
+            metrics: { accuracy: 0.95 },
+            evaluatedAt: new Date(),
+        });
+        const { a, b, winner } = service.compareVersions('m', 'a', 'b');
+        expect(a?.metrics.accuracy).toBe(0.9);
+        expect(b?.metrics.accuracy).toBe(0.95);
+        expect(winner).toBe('b');
+    });
+    it('compareVersions when no accuracy', () => {
+        service.recordEvaluation({
+            modelName: 'm',
+            version: 'a',
+            metrics: {},
+            evaluatedAt: new Date(),
+        });
+        const { winner } = service.compareVersions('m', 'a', 'b');
+        expect(winner).toBeUndefined();
+    });
+    describe('evaluate', () => {
+        let EvalModel = class EvalModel {
+            train() { }
+            async predict(input) {
+                const sentiment = input.text.includes('good') ? 'positive' : 'negative';
+                return { sentiment };
+            }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], EvalModel.prototype, "train", null);
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], EvalModel.prototype, "predict", null);
+        EvalModel = __decorate([
+            (0, decorators_1.Model)({ name: 'eval-model', version: '1.0.0', framework: 'custom' })
+        ], EvalModel);
+        it('throws when PredictorService not injected', async () => {
+            const svc = new metrics_service_1.MetricsService();
+            await expect(svc.evaluate('any', [{ text: 'hello', label: 'neutral' }])).rejects.toThrow('MetricsService.evaluate() requires PredictorService');
+        });
+        it('throws when testData is empty', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            await expect(svc.evaluate('eval-model', [])).rejects.toThrow('testData cannot be empty');
+        });
+        it('computes accuracy, precision, recall, f1 from test data', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const testData = [
+                { text: 'good day', label: 'positive' },
+                { text: 'bad day', label: 'negative' },
+                { text: 'good weather', label: 'positive' },
+                { text: 'bad weather', label: 'negative' },
+            ];
+            const result = await svc.evaluate('eval-model', testData);
+            expect(result.modelName).toBe('eval-model');
+            expect(result.version).toBe('1.0.0');
+            expect(result.metrics.accuracy).toBe(1);
+            expect(result.metrics.precision).toBe(1);
+            expect(result.metrics.recall).toBe(1);
+            expect(result.metrics.f1Score).toBe(1);
+        });
+        it('supports custom labelKey and predictionKey', async () => {
+            let CustomModel = class CustomModel {
+                train() { }
+                async predict(input) {
+                    return { outcome: input.x === 'a' ? 'yes' : 'no' };
+                }
+            };
+            __decorate([
+                (0, decorators_1.Train)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], CustomModel.prototype, "train", null);
+            __decorate([
+                (0, decorators_1.Predict)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", Promise)
+            ], CustomModel.prototype, "predict", null);
+            CustomModel = __decorate([
+                (0, decorators_1.Model)({ name: 'custom-model', version: '1.0.0', framework: 'custom' })
+            ], CustomModel);
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'custom-model', version: '1.0.0', framework: 'custom' },
+                instance: new CustomModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const result = await svc.evaluate('custom-model', [
+                { x: 'a', outcome: 'yes' },
+                { x: 'b', outcome: 'no' },
+            ], { labelKey: 'outcome', predictionKey: 'outcome' });
+            expect(result.metrics.accuracy).toBe(1);
+        });
+        it('extractPredictedLabel uses first value when no known key', async () => {
+            let FallbackModel = class FallbackModel {
+                train() { }
+                async predict() {
+                    return { customKey: 'positive' };
+                }
+            };
+            __decorate([
+                (0, decorators_1.Train)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], FallbackModel.prototype, "train", null);
+            __decorate([
+                (0, decorators_1.Predict)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", Promise)
+            ], FallbackModel.prototype, "predict", null);
+            FallbackModel = __decorate([
+                (0, decorators_1.Model)({ name: 'fallback-model', version: '1.0.0', framework: 'custom' })
+            ], FallbackModel);
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'fallback-model', version: '1.0.0', framework: 'custom' },
+                instance: new FallbackModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const result = await svc.evaluate('fallback-model', [{ text: 'x', label: 'positive' }], {
+                metrics: ['accuracy'],
+            });
+            expect(result.metrics.accuracy).toBe(1);
+        });
+        it('evaluate with only accuracy metric skips precision/recall/f1', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const result = await svc.evaluate('eval-model', [{ text: 'good', label: 'positive' }], {
+                metrics: ['accuracy'],
+            });
+            expect(result.metrics.accuracy).toBeDefined();
+            expect(result.metrics.precision).toBeUndefined();
+            expect(result.metrics.recall).toBeUndefined();
+            expect(result.metrics.f1Score).toBeUndefined();
+        });
+        it('evaluate when modelRegistry is undefined uses version unknown', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(undefined, predictor);
+            const result = await svc.evaluate('eval-model', [{ text: 'good', label: 'positive' }]);
+            expect(result.version).toBeDefined();
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @hazeljs/ml - Machine Learning & Model Management for HazelJS
+ */
+import 'reflect-metadata';
+export { MLModule, ML_MODELS, type MLModuleOptions } from './ml.module';
+export { Model, Train, Predict, getModelMetadata, hasModelMetadata, getTrainMetadata, hasTrainMetadata, getPredictMetadata, hasPredictMetadata, type TrainOptions, type PredictOptions, } from './decorators';
+export { ModelRegistry, type RegisteredModel } from './registry/model.registry';
+export { TrainerService } from './training/trainer.service';
+export { PipelineService, type PipelineStep } from './training/pipeline.service';
+export { PredictorService } from './inference/predictor.service';
+export { BatchService, type BatchPredictionOptions } from './inference/batch.service';
+export { MetricsService, type ModelMetrics, type EvaluationResult, type EvaluateOptions, type EvaluateMetric, } from './evaluation/metrics.service';
+export { registerMLModel } from './ml-model.base';
+export { Injectable } from '@hazeljs/core';
+export type { MLFramework, ModelMetadata, TrainingData, TrainingResult, PredictionResult, ModelVersion, } from './ml.types';
+//# 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;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAG1B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAGxE,OAAO,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGhF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,EACL,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,YAAY,EACV,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * @hazeljs/ml - Machine Learning & Model Management for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = exports.registerMLModel = exports.MetricsService = exports.BatchService = exports.PredictorService = exports.PipelineService = exports.TrainerService = exports.ModelRegistry = exports.hasPredictMetadata = exports.getPredictMetadata = exports.hasTrainMetadata = exports.getTrainMetadata = exports.hasModelMetadata = exports.getModelMetadata = exports.Predict = exports.Train = exports.Model = exports.ML_MODELS = exports.MLModule = void 0;
+require("reflect-metadata");
+// Module
+var ml_module_1 = require("./ml.module");
+Object.defineProperty(exports, "MLModule", { enumerable: true, get: function () { return ml_module_1.MLModule; } });
+Object.defineProperty(exports, "ML_MODELS", { enumerable: true, get: function () { return ml_module_1.ML_MODELS; } });
+// Decorators
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return decorators_1.Model; } });
+Object.defineProperty(exports, "Train", { enumerable: true, get: function () { return decorators_1.Train; } });
+Object.defineProperty(exports, "Predict", { enumerable: true, get: function () { return decorators_1.Predict; } });
+Object.defineProperty(exports, "getModelMetadata", { enumerable: true, get: function () { return decorators_1.getModelMetadata; } });
+Object.defineProperty(exports, "hasModelMetadata", { enumerable: true, get: function () { return decorators_1.hasModelMetadata; } });
+Object.defineProperty(exports, "getTrainMetadata", { enumerable: true, get: function () { return decorators_1.getTrainMetadata; } });
+Object.defineProperty(exports, "hasTrainMetadata", { enumerable: true, get: function () { return decorators_1.hasTrainMetadata; } });
+Object.defineProperty(exports, "getPredictMetadata", { enumerable: true, get: function () { return decorators_1.getPredictMetadata; } });
+Object.defineProperty(exports, "hasPredictMetadata", { enumerable: true, get: function () { return decorators_1.hasPredictMetadata; } });
+// Registry
+var model_registry_1 = require("./registry/model.registry");
+Object.defineProperty(exports, "ModelRegistry", { enumerable: true, get: function () { return model_registry_1.ModelRegistry; } });
+// Services
+var trainer_service_1 = require("./training/trainer.service");
+Object.defineProperty(exports, "TrainerService", { enumerable: true, get: function () { return trainer_service_1.TrainerService; } });
+var pipeline_service_1 = require("./training/pipeline.service");
+Object.defineProperty(exports, "PipelineService", { enumerable: true, get: function () { return pipeline_service_1.PipelineService; } });
+var predictor_service_1 = require("./inference/predictor.service");
+Object.defineProperty(exports, "PredictorService", { enumerable: true, get: function () { return predictor_service_1.PredictorService; } });
+var batch_service_1 = require("./inference/batch.service");
+Object.defineProperty(exports, "BatchService", { enumerable: true, get: function () { return batch_service_1.BatchService; } });
+var metrics_service_1 = require("./evaluation/metrics.service");
+Object.defineProperty(exports, "MetricsService", { enumerable: true, get: function () { return metrics_service_1.MetricsService; } });
+// Model registration helper
+var ml_model_base_1 = require("./ml-model.base");
+Object.defineProperty(exports, "registerMLModel", { enumerable: true, get: function () { return ml_model_base_1.registerMLModel; } });
+// Re-export Injectable from core for convenience
+var core_1 = require("@hazeljs/core");
+Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return core_1.Injectable; } });

package/dist/inference/batch.service.d.ts

@@ -0,0 +1,16 @@
+import { PredictorService } from './predictor.service';
+import { PredictionResult } from '../ml.types';
+export interface BatchPredictionOptions {
+    batchSize?: number;
+    concurrency?: number;
+}
+/**
+ * Batch Service - Batch processing for inference
+ * Handles bulk prediction requests efficiently
+ */
+export declare class BatchService {
+    private readonly predictorService;
+    constructor(predictorService: PredictorService);
+    predictBatch<T = unknown>(modelName: string, inputs: unknown[], options?: BatchPredictionOptions, version?: string): Promise<PredictionResult<T>[]>;
+}
+//# sourceMappingURL=batch.service.d.ts.map

package/dist/inference/batch.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.service.d.ts","sourceRoot":"","sources":["../../src/inference/batch.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,qBACa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBAAhB,gBAAgB,EAAE,gBAAgB;IAEzD,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,EAAE,EACjB,OAAO,GAAE,sBAA2B,EACpC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;CA+BlC"}

package/dist/inference/batch.service.js

@@ -0,0 +1,52 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchService = void 0;
+const core_1 = require("@hazeljs/core");
+const predictor_service_1 = require("./predictor.service");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Batch Service - Batch processing for inference
+ * Handles bulk prediction requests efficiently
+ */
+let BatchService = class BatchService {
+    constructor(predictorService) {
+        this.predictorService = predictorService;
+    }
+    async predictBatch(modelName, inputs, options = {}, version) {
+        const { batchSize = 32, concurrency = 4 } = options;
+        core_2.default.debug(`Batch prediction: ${inputs.length} inputs, batchSize=${batchSize}`);
+        const results = new Array(inputs.length);
+        const batches = [];
+        for (let i = 0; i < inputs.length; i += batchSize) {
+            const batch = inputs.slice(i, i + batchSize).map((input, j) => ({ input, idx: i + j }));
+            batches.push(batch);
+        }
+        for (let i = 0; i < batches.length; i += concurrency) {
+            const batchGroup = batches.slice(i, i + concurrency);
+            const batchResults = await Promise.all(batchGroup.flatMap((batch) => batch.map(({ input, idx }) => this.predictorService
+                .predict(modelName, input, version)
+                .then((r) => ({ idx, r })))));
+            for (const { idx, r } of batchResults) {
+                results[idx] = r;
+            }
+        }
+        return results;
+    }
+};
+exports.BatchService = BatchService;
+exports.BatchService = BatchService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [predictor_service_1.PredictorService])
+], BatchService);

package/dist/inference/batch.service.test.d.ts

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

package/dist/inference/batch.service.test.d.ts.map

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

package/dist/inference/batch.service.test.js

@@ -0,0 +1,86 @@
+"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 });
+const model_registry_1 = require("../registry/model.registry");
+const predictor_service_1 = require("./predictor.service");
+const batch_service_1 = require("./batch.service");
+const decorators_1 = require("../decorators");
+describe('BatchService', () => {
+    let batchService;
+    let BatchModel = class BatchModel {
+        train() { }
+        async predict(input) {
+            return { value: input * 2 };
+        }
+    };
+    __decorate([
+        (0, decorators_1.Train)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], BatchModel.prototype, "train", null);
+    __decorate([
+        (0, decorators_1.Predict)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], BatchModel.prototype, "predict", null);
+    BatchModel = __decorate([
+        (0, decorators_1.Model)({ name: 'batch-model', version: '1.0.0', framework: 'tensorflow' })
+    ], BatchModel);
+    beforeEach(() => {
+        const registry = new model_registry_1.ModelRegistry();
+        registry.register({
+            metadata: { name: 'batch-model', version: '1.0.0', framework: 'tensorflow' },
+            instance: new BatchModel(),
+            predictMethod: 'predict',
+        });
+        batchService = new batch_service_1.BatchService(new predictor_service_1.PredictorService(registry));
+    });
+    it('processes batch of inputs', async () => {
+        const results = await batchService.predictBatch('batch-model', [1, 2, 3]);
+        expect(results).toEqual([{ value: 2 }, { value: 4 }, { value: 6 }]);
+    });
+    it('respects batchSize option', async () => {
+        const results = await batchService.predictBatch('batch-model', [1, 2, 3, 4, 5], {
+            batchSize: 2,
+        });
+        expect(results).toHaveLength(5);
+    });
+    it('preserves result order matching input order', async () => {
+        const inputs = [10, 20, 30, 40, 50];
+        const results = await batchService.predictBatch('batch-model', inputs, {
+            batchSize: 2,
+            concurrency: 2,
+        });
+        expect(results).toEqual([
+            { value: 20 },
+            { value: 40 },
+            { value: 60 },
+            { value: 80 },
+            { value: 100 },
+        ]);
+    });
+    it('throws when model not found', async () => {
+        await expect(batchService.predictBatch('unknown', [1])).rejects.toThrow('Model not found: unknown');
+    });
+    it('uses default batchSize and concurrency when options empty', async () => {
+        const results = await batchService.predictBatch('batch-model', [1, 2], {});
+        expect(results).toHaveLength(2);
+        expect(results).toEqual([{ value: 2 }, { value: 4 }]);
+    });
+    it('uses custom concurrency with default batchSize', async () => {
+        const results = await batchService.predictBatch('batch-model', [1, 2, 3], {
+            concurrency: 1,
+        });
+        expect(results).toEqual([{ value: 2 }, { value: 4 }, { value: 6 }]);
+    });
+});

package/dist/inference/predictor.service.d.ts

@@ -0,0 +1,13 @@
+import { ModelRegistry } from '../registry/model.registry';
+import { PredictionResult } from '../ml.types';
+/**
+ * Predictor Service - Real-time prediction/inference
+ * Routes prediction requests to registered models
+ */
+export declare class PredictorService {
+    private readonly modelRegistry;
+    constructor(modelRegistry: ModelRegistry);
+    predict<T = unknown>(modelName: string, input: unknown, version?: string): Promise<PredictionResult<T>>;
+    discoverPredictMethod(instance: object): string | undefined;
+}
+//# sourceMappingURL=predictor.service.d.ts.map

package/dist/inference/predictor.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictor.service.d.ts","sourceRoot":"","sources":["../../src/inference/predictor.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C;;;GAGG;AACH,qBACa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEnD,OAAO,CAAC,CAAC,GAAG,OAAO,EACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAyB/B,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAa5D"}

package/dist/inference/predictor.service.js

@@ -0,0 +1,65 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictorService = void 0;
+const core_1 = require("@hazeljs/core");
+const model_registry_1 = require("../registry/model.registry");
+const decorators_1 = require("../decorators");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Predictor Service - Real-time prediction/inference
+ * Routes prediction requests to registered models
+ */
+let PredictorService = class PredictorService {
+    constructor(modelRegistry) {
+        this.modelRegistry = modelRegistry;
+    }
+    async predict(modelName, input, version) {
+        const model = this.modelRegistry.get(modelName, version);
+        if (!model) {
+            throw new Error(`Model not found: ${modelName}`);
+        }
+        const predictMethod = model.predictMethod;
+        if (!predictMethod) {
+            throw new Error(`Model ${modelName} has no prediction method`);
+        }
+        const instance = model.instance;
+        const predictFn = instance[predictMethod];
+        if (typeof predictFn !== 'function') {
+            throw new Error(`Prediction method ${predictMethod} not found on model`);
+        }
+        core_2.default.debug(`Running prediction for model: ${modelName}`);
+        const result = await predictFn.call(instance, input);
+        return result;
+    }
+    discoverPredictMethod(instance) {
+        const proto = Object.getPrototypeOf(instance);
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (key === 'constructor')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+            if (descriptor?.value && typeof descriptor.value === 'function') {
+                if ((0, decorators_1.getPredictMetadata)(proto, key)) {
+                    return key;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+exports.PredictorService = PredictorService;
+exports.PredictorService = PredictorService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry])
+], PredictorService);

package/dist/inference/predictor.service.test.d.ts

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

package/dist/inference/predictor.service.test.d.ts.map

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