@hazeljs/ml 0.2.0-beta.54 → 0.2.0-beta.55

package/dist/decorators/model.decorator.test.d.ts

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

package/dist/decorators/model.decorator.test.d.ts.map

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

package/dist/decorators/model.decorator.test.js

@@ -0,0 +1,128 @@
+"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 model_decorator_1 = require("./model.decorator");
+const train_decorator_1 = require("./train.decorator");
+const predict_decorator_1 = require("./predict.decorator");
+describe('Model decorator', () => {
+    it('applies metadata to class', () => {
+        let TestModel = class TestModel {
+        };
+        TestModel = __decorate([
+            (0, model_decorator_1.Model)({ name: 'test-model', version: '1.0.0', framework: 'tensorflow' })
+        ], TestModel);
+        const meta = (0, model_decorator_1.getModelMetadata)(TestModel);
+        expect(meta).toEqual({
+            name: 'test-model',
+            version: '1.0.0',
+            framework: 'tensorflow',
+            description: '',
+            tags: [],
+        });
+        expect((0, model_decorator_1.hasModelMetadata)(TestModel)).toBe(true);
+    });
+    it('merges optional fields', () => {
+        let CustomModel = class CustomModel {
+        };
+        CustomModel = __decorate([
+            (0, model_decorator_1.Model)({
+                name: 'custom',
+                version: '2.0.0',
+                framework: 'onnx',
+                description: 'A model',
+                tags: ['production'],
+            })
+        ], CustomModel);
+        const meta = (0, model_decorator_1.getModelMetadata)(CustomModel);
+        expect(meta?.description).toBe('A model');
+        expect(meta?.tags).toEqual(['production']);
+    });
+    it('hasModelMetadata returns false for undecorated class', () => {
+        class PlainClass {
+        }
+        expect((0, model_decorator_1.hasModelMetadata)(PlainClass)).toBe(false);
+        expect((0, model_decorator_1.getModelMetadata)(PlainClass)).toBeUndefined();
+    });
+});
+describe('Train decorator', () => {
+    it('applies metadata to method', () => {
+        class TestClass {
+            train() { }
+        }
+        __decorate([
+            (0, train_decorator_1.Train)({ pipeline: 'default', epochs: 5 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "train", null);
+        const meta = (0, train_decorator_1.getTrainMetadata)(TestClass.prototype, 'train');
+        expect(meta).toEqual({
+            pipeline: 'default',
+            batchSize: 32,
+            epochs: 5,
+        });
+        expect((0, train_decorator_1.hasTrainMetadata)(TestClass.prototype, 'train')).toBe(true);
+    });
+    it('uses defaults when no options', () => {
+        class TestClass {
+            train() { }
+        }
+        __decorate([
+            (0, train_decorator_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "train", null);
+        const meta = (0, train_decorator_1.getTrainMetadata)(TestClass.prototype, 'train');
+        expect(meta?.batchSize).toBe(32);
+        expect(meta?.epochs).toBe(10);
+    });
+    it('hasTrainMetadata returns false for undecorated method', () => {
+        class TestClass {
+            train() { }
+        }
+        expect((0, train_decorator_1.hasTrainMetadata)(TestClass.prototype, 'train')).toBe(false);
+    });
+});
+describe('Predict decorator', () => {
+    it('applies metadata to method', () => {
+        class TestClass {
+            predict() { }
+        }
+        __decorate([
+            (0, predict_decorator_1.Predict)({ endpoint: '/predict', batch: true }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "predict", null);
+        const meta = (0, predict_decorator_1.getPredictMetadata)(TestClass.prototype, 'predict');
+        expect(meta).toEqual({
+            batch: true,
+            endpoint: '/predict',
+        });
+        expect((0, predict_decorator_1.hasPredictMetadata)(TestClass.prototype, 'predict')).toBe(true);
+    });
+    it('uses defaults when no options', () => {
+        class TestClass {
+            predict() { }
+        }
+        __decorate([
+            (0, predict_decorator_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "predict", null);
+        const meta = (0, predict_decorator_1.getPredictMetadata)(TestClass.prototype, 'predict');
+        expect(meta?.batch).toBe(false);
+        expect(meta?.endpoint).toBe('/predict');
+    });
+});

package/dist/evaluation/metrics.service.js

@@ -50,5 +50,5 @@ let MetricsService = class MetricsService {
 };
 exports.MetricsService = MetricsService;
 exports.MetricsService = MetricsService = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], MetricsService);

package/dist/evaluation/metrics.service.test.d.ts

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

package/dist/evaluation/metrics.service.test.d.ts.map

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

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metrics_service_1 = require("./metrics.service");
+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();
+    });
+});

package/dist/inference/batch.service.js

@@ -42,6 +42,6 @@ let BatchService = class BatchService {
 };
 exports.BatchService = BatchService;
 exports.BatchService = BatchService = __decorate([
-    (0, core_1.Injectable)(),
+    (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,61 @@
+"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('throws when model not found', async () => {
+        await expect(batchService.predictBatch('unknown', [1])).rejects.toThrow('Model not found: unknown');
+    });
+});

package/dist/inference/predictor.service.js

@@ -60,6 +60,6 @@ let PredictorService = class PredictorService {
 };
 exports.PredictorService = PredictorService;
 exports.PredictorService = PredictorService = __decorate([
-    (0, core_1.Injectable)(),
+    (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":""}

package/dist/inference/predictor.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 decorators_1 = require("../decorators");
+describe('PredictorService', () => {
+    let registry;
+    let predictor;
+    let TestModel = class TestModel {
+        async train() {
+            return { accuracy: 0.9 };
+        }
+        async predict(input) {
+            return { sentiment: 'positive', score: 0.92, input };
+        }
+    };
+    __decorate([
+        (0, decorators_1.Train)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], TestModel.prototype, "train", null);
+    __decorate([
+        (0, decorators_1.Predict)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestModel.prototype, "predict", null);
+    TestModel = __decorate([
+        (0, decorators_1.Model)({ name: 'test-model', version: '1.0.0', framework: 'tensorflow' })
+    ], TestModel);
+    beforeEach(() => {
+        registry = new model_registry_1.ModelRegistry();
+        predictor = new predictor_service_1.PredictorService(registry);
+        registry.register({
+            metadata: { name: 'test-model', version: '1.0.0', framework: 'tensorflow' },
+            instance: new TestModel(),
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        });
+    });
+    it('predicts and returns result', async () => {
+        const result = await predictor.predict('test-model', 'hello');
+        expect(result).toEqual({ sentiment: 'positive', score: 0.92, input: 'hello' });
+    });
+    it('predicts with specific version', async () => {
+        const result = await predictor.predict('test-model', 'hi', '1.0.0');
+        expect(result.sentiment).toBe('positive');
+    });
+    it('throws when model not found', async () => {
+        await expect(predictor.predict('unknown', {})).rejects.toThrow('Model not found: unknown');
+    });
+    it('throws when model has no prediction method', async () => {
+        let NoPredictModel = class NoPredictModel {
+            train() { }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], NoPredictModel.prototype, "train", null);
+        NoPredictModel = __decorate([
+            (0, decorators_1.Model)({ name: 'no-predict', version: '1.0.0', framework: 'tensorflow' })
+        ], NoPredictModel);
+        registry.register({
+            metadata: { name: 'no-predict', version: '1.0.0', framework: 'tensorflow' },
+            instance: new NoPredictModel(),
+            trainMethod: 'train',
+        });
+        await expect(predictor.predict('no-predict', {})).rejects.toThrow('no-predict has no prediction method');
+    });
+    it('discoverPredictMethod finds @Predict decorated method', () => {
+        const instance = new TestModel();
+        expect(predictor.discoverPredictMethod(instance)).toBe('predict');
+    });
+});

package/dist/ml-model.base.test.d.ts

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

package/dist/ml-model.base.test.d.ts.map

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

package/dist/ml-model.base.test.js

@@ -0,0 +1,57 @@
+"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 ml_model_base_1 = require("./ml-model.base");
+const model_registry_1 = require("./registry/model.registry");
+const trainer_service_1 = require("./training/trainer.service");
+const predictor_service_1 = require("./inference/predictor.service");
+const decorators_1 = require("./decorators");
+let RegisterTestModel = class RegisterTestModel {
+    train() { }
+    predict() { }
+};
+__decorate([
+    (0, decorators_1.Train)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], RegisterTestModel.prototype, "train", null);
+__decorate([
+    (0, decorators_1.Predict)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], RegisterTestModel.prototype, "predict", null);
+RegisterTestModel = __decorate([
+    (0, decorators_1.Model)({ name: 'register-test', version: '1.0.0', framework: 'tensorflow' })
+], RegisterTestModel);
+describe('registerMLModel', () => {
+    it('registers model with registry', () => {
+        const registry = new model_registry_1.ModelRegistry();
+        const trainer = new trainer_service_1.TrainerService(registry);
+        const predictor = new predictor_service_1.PredictorService(registry);
+        const instance = new RegisterTestModel();
+        (0, ml_model_base_1.registerMLModel)(instance, registry, trainer, predictor);
+        const registered = registry.get('register-test', '1.0.0');
+        expect(registered).toBeDefined();
+        expect(registered?.trainMethod).toBe('train');
+        expect(registered?.predictMethod).toBe('predict');
+    });
+    it('does nothing for class without @Model', () => {
+        const registry = new model_registry_1.ModelRegistry();
+        const trainer = new trainer_service_1.TrainerService(registry);
+        const predictor = new predictor_service_1.PredictorService(registry);
+        class PlainClass {
+        }
+        (0, ml_model_base_1.registerMLModel)(new PlainClass(), registry, trainer, predictor);
+        expect(registry.list()).toHaveLength(0);
+    });
+});

package/dist/ml.module.test.d.ts

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

package/dist/ml.module.test.d.ts.map

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

package/dist/ml.module.test.js

@@ -0,0 +1,60 @@
+"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 ml_module_1 = require("./ml.module");
+const decorators_1 = require("./decorators");
+let TestModel = class TestModel {
+    train() { }
+    predict() { }
+};
+__decorate([
+    (0, decorators_1.Train)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestModel.prototype, "train", null);
+__decorate([
+    (0, decorators_1.Predict)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestModel.prototype, "predict", null);
+TestModel = __decorate([
+    (0, decorators_1.Model)({ name: 'test', version: '1.0.0', framework: 'tensorflow' })
+], TestModel);
+describe('MLModule', () => {
+    describe('forRoot', () => {
+        it('returns dynamic module structure', () => {
+            const result = ml_module_1.MLModule.forRoot();
+            expect(result).toHaveProperty('module', ml_module_1.MLModule);
+            expect(result).toHaveProperty('providers');
+            expect(result).toHaveProperty('exports');
+            expect(Array.isArray(result.providers)).toBe(true);
+            expect(result.providers.length).toBeGreaterThan(0);
+        });
+        it('includes models in providers when specified', () => {
+            const result = ml_module_1.MLModule.forRoot({ models: [TestModel] });
+            expect(result.providers).toContain(TestModel);
+        });
+        it('includes ML_MODELS and MLModelBootstrap when models provided', () => {
+            const result = ml_module_1.MLModule.forRoot({ models: [TestModel] });
+            const mlModels = result.providers.find((p) => p && typeof p === 'object' && 'provide' in p);
+            expect(mlModels).toBeDefined();
+        });
+    });
+    describe('getOptions', () => {
+        it('returns last forRoot options', () => {
+            ml_module_1.MLModule.forRoot({ models: [TestModel] });
+            const opts = ml_module_1.MLModule.getOptions();
+            expect(opts.models).toContain(TestModel);
+        });
+    });
+});

package/dist/registry/model.registry.js

@@ -60,5 +60,5 @@ let ModelRegistry = class ModelRegistry {
 };
 exports.ModelRegistry = ModelRegistry;
 exports.ModelRegistry = ModelRegistry = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], ModelRegistry);

package/dist/registry/model.registry.test.d.ts

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

package/dist/registry/model.registry.test.d.ts.map

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

package/dist/registry/model.registry.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_registry_1 = require("./model.registry");
+describe('ModelRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        registry = new model_registry_1.ModelRegistry();
+    });
+    it('registers and retrieves model by name and version', () => {
+        const model = {
+            metadata: { name: 'sentiment', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        };
+        registry.register(model);
+        const retrieved = registry.get('sentiment', '1.0.0');
+        expect(retrieved).toBe(model);
+    });
+    it('returns latest version when version not specified', () => {
+        const v1 = {
+            metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        };
+        const v2 = {
+            metadata: { name: 'model', version: '2.0.0', framework: 'tensorflow' },
+            instance: {},
+        };
+        registry.register(v1);
+        registry.register(v2);
+        expect(registry.get('model')).toBe(v2);
+        expect(registry.get('model', '1.0.0')).toBe(v1);
+    });
+    it('returns undefined for unknown model', () => {
+        expect(registry.get('unknown')).toBeUndefined();
+        expect(registry.get('unknown', '1.0.0')).toBeUndefined();
+    });
+    it('lists all registered models', () => {
+        registry.register({
+            metadata: { name: 'a', version: '1', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.register({
+            metadata: { name: 'b', version: '1', framework: 'onnx' },
+            instance: {},
+        });
+        const list = registry.list();
+        expect(list).toHaveLength(2);
+        expect(list.map((m) => m.name)).toContain('a');
+        expect(list.map((m) => m.name)).toContain('b');
+    });
+    it('getVersions returns version history', () => {
+        registry.register({
+            metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.register({
+            metadata: { name: 'model', version: '2.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        const versions = registry.getVersions('model');
+        expect(versions).toHaveLength(2);
+        expect(versions.map((v) => v.version)).toEqual(['1.0.0', '2.0.0']);
+    });
+    it('unregister removes model', () => {
+        registry.register({
+            metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        expect(registry.get('model', '1.0.0')).toBeDefined();
+        const deleted = registry.unregister('model', '1.0.0');
+        expect(deleted).toBe(true);
+        expect(registry.get('model', '1.0.0')).toBeUndefined();
+        expect(registry.unregister('model', '1.0.0')).toBe(false);
+    });
+});

package/dist/training/pipeline.service.js

@@ -45,5 +45,5 @@ let PipelineService = class PipelineService {
 };
 exports.PipelineService = PipelineService;
 exports.PipelineService = PipelineService = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], PipelineService);

package/dist/training/pipeline.service.test.d.ts

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

package/dist/training/pipeline.service.test.d.ts.map

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

package/dist/training/pipeline.service.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_service_1 = require("./pipeline.service");
+describe('PipelineService', () => {
+    let service;
+    beforeEach(() => {
+        service = new pipeline_service_1.PipelineService();
+    });
+    it('registers and runs pipeline', async () => {
+        service.registerPipeline('test', [
+            { name: 'step1', transform: (d) => ({ ...d, a: 1 }) },
+            { name: 'step2', transform: (d) => ({ ...d, b: 2 }) },
+        ]);
+        const result = await service.run('test', { x: 0 });
+        expect(result).toEqual({ x: 0, a: 1, b: 2 });
+    });
+    it('handles async transforms', async () => {
+        service.registerPipeline('async', [
+            { name: 'async', transform: async (d) => ({ ...d, done: true }) },
+        ]);
+        const result = await service.run('async', {});
+        expect(result).toEqual({ done: true });
+    });
+    it('throws when pipeline not found', async () => {
+        await expect(service.run('missing', {})).rejects.toThrow('Pipeline not found: missing');
+    });
+    it('getPipeline returns steps', () => {
+        const steps = [{ name: 's1', transform: (d) => d }];
+        service.registerPipeline('p', steps);
+        expect(service.getPipeline('p')).toEqual(steps);
+        expect(service.getPipeline('x')).toBeUndefined();
+    });
+    it('listPipelines returns names', () => {
+        service.registerPipeline('a', []);
+        service.registerPipeline('b', []);
+        expect(service.listPipelines()).toEqual(['a', 'b']);
+    });
+});

package/dist/training/trainer.service.js

@@ -64,6 +64,6 @@ let TrainerService = class TrainerService {
 };
 exports.TrainerService = TrainerService;
 exports.TrainerService = TrainerService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [model_registry_1.ModelRegistry])
 ], TrainerService);

package/dist/training/trainer.service.test.d.ts

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

package/dist/training/trainer.service.test.d.ts.map

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

package/dist/training/trainer.service.test.js

@@ -0,0 +1,89 @@
+"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 trainer_service_1 = require("./trainer.service");
+const decorators_1 = require("../decorators");
+describe('TrainerService', () => {
+    let registry;
+    let trainer;
+    let TestModel = class TestModel {
+        async train(data) {
+            return { accuracy: 0.95, loss: 0.05, inputSize: data?.size };
+        }
+        async predict() {
+            return { value: 1 };
+        }
+    };
+    __decorate([
+        (0, decorators_1.Train)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], TestModel.prototype, "train", null);
+    __decorate([
+        (0, decorators_1.Predict)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], TestModel.prototype, "predict", null);
+    TestModel = __decorate([
+        (0, decorators_1.Model)({ name: 'test-model', version: '1.0.0', framework: 'tensorflow' })
+    ], TestModel);
+    beforeEach(() => {
+        registry = new model_registry_1.ModelRegistry();
+        trainer = new trainer_service_1.TrainerService(registry);
+        const instance = new TestModel();
+        registry.register({
+            metadata: { name: 'test-model', version: '1.0.0', framework: 'tensorflow' },
+            instance,
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        });
+    });
+    it('trains model and returns result', async () => {
+        const result = await trainer.train('test-model', { size: 100 });
+        expect(result).toEqual({ accuracy: 0.95, loss: 0.05, inputSize: 100 });
+    });
+    it('throws when model not found', async () => {
+        await expect(trainer.train('unknown', {})).rejects.toThrow('Model not found: unknown');
+    });
+    it('throws when model has no training method', async () => {
+        let NoTrainModel = class NoTrainModel {
+            predict() { }
+        };
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], NoTrainModel.prototype, "predict", null);
+        NoTrainModel = __decorate([
+            (0, decorators_1.Model)({ name: 'no-train', version: '1.0.0', framework: 'tensorflow' })
+        ], NoTrainModel);
+        registry.register({
+            metadata: { name: 'no-train', version: '1.0.0', framework: 'tensorflow' },
+            instance: new NoTrainModel(),
+            predictMethod: 'predict',
+        });
+        await expect(trainer.train('no-train', {})).rejects.toThrow('no-train has no training method');
+    });
+    it('discoverTrainMethod finds @Train decorated method', () => {
+        const instance = new TestModel();
+        expect(trainer.discoverTrainMethod(instance)).toBe('train');
+    });
+    it('discoverTrainMethod returns undefined for class without @Model', () => {
+        class PlainClass {
+            train() { }
+        }
+        expect(trainer.discoverTrainMethod(new PlainClass())).toBeUndefined();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/ml",
-  "version": "0.2.0-beta.54",
+  "version": "0.2.0-beta.55",
   "description": "Machine Learning & Model Management for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,5 +48,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "c593ce33447cdc62d7bd2386cc2db47840292fcb"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }