@hazeljs/ml 0.2.0-alpha.1

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

@@ -0,0 +1,115 @@
+"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');
+    });
+    it('throws when predict method is not a function', async () => {
+        const fakeInstance = {
+            predict: 'not-a-function',
+        };
+        registry.register({
+            metadata: { name: 'broken-model', version: '1.0.0', framework: 'custom' },
+            instance: fakeInstance,
+            trainMethod: undefined,
+            predictMethod: 'predict',
+        });
+        await expect(predictor.predict('broken-model', {})).rejects.toThrow('Prediction method predict not found on model');
+    });
+    it('discoverPredictMethod returns undefined when no @Predict method', () => {
+        let NoPredictClass = class NoPredictClass {
+            train() { }
+            someMethod() { }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], NoPredictClass.prototype, "train", null);
+        NoPredictClass = __decorate([
+            (0, decorators_1.Model)({ name: 'no-predict-method', version: '1.0.0', framework: 'custom' })
+        ], NoPredictClass);
+        const instance = new NoPredictClass();
+        expect(predictor.discoverPredictMethod(instance)).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,20 @@
+import { ModelRegistry } from './registry/model.registry';
+import { TrainerService } from './training/trainer.service';
+import { PredictorService } from './inference/predictor.service';
+/**
+ * Registers an ML model instance with the registry.
+ * Call this from your model's constructor when injecting ModelRegistry.
+ *
+ * @example
+ * ```typescript
+ * @Model({ name: 'sentiment', version: '1.0.0', framework: 'tensorflow' })
+ * @Injectable()
+ * class SentimentModel extends MLModelBase {
+ *   constructor(registry: ModelRegistry, trainer: TrainerService, predictor: PredictorService) {
+ *     super(registry, trainer, predictor);
+ *   }
+ * }
+ * ```
+ */
+export declare function registerMLModel(instance: object, registry: ModelRegistry, trainerService: TrainerService, predictorService: PredictorService): void;
+//# sourceMappingURL=ml-model.base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ml-model.base.d.ts","sourceRoot":"","sources":["../src/ml-model.base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGjE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,aAAa,EACvB,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,gBAAgB,GACjC,IAAI,CAcN"}

package/dist/ml-model.base.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMLModel = registerMLModel;
+const decorators_1 = require("./decorators");
+/**
+ * Registers an ML model instance with the registry.
+ * Call this from your model's constructor when injecting ModelRegistry.
+ *
+ * @example
+ * ```typescript
+ * @Model({ name: 'sentiment', version: '1.0.0', framework: 'tensorflow' })
+ * @Injectable()
+ * class SentimentModel extends MLModelBase {
+ *   constructor(registry: ModelRegistry, trainer: TrainerService, predictor: PredictorService) {
+ *     super(registry, trainer, predictor);
+ *   }
+ * }
+ * ```
+ */
+function registerMLModel(instance, registry, trainerService, predictorService) {
+    const metadata = (0, decorators_1.getModelMetadata)(instance.constructor);
+    if (!metadata)
+        return;
+    const trainMethod = trainerService.discoverTrainMethod(instance);
+    const predictMethod = predictorService.discoverPredictMethod(instance);
+    const registered = {
+        metadata,
+        instance,
+        trainMethod,
+        predictMethod,
+    };
+    registry.register(registered);
+}

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.d.ts

@@ -0,0 +1,27 @@
+import { type Type } from '@hazeljs/core';
+export declare const ML_MODELS: unique symbol;
+export interface MLModuleOptions {
+    models?: Type<unknown>[];
+}
+export declare class MLModule {
+    private static options;
+    /**
+     * Configure MLModule with models to register
+     *
+     * @example
+     * ```typescript
+     * imports: [
+     *   MLModule.forRoot({
+     *     models: [SentimentModel],
+     *   }),
+     * ]
+     * ```
+     */
+    static forRoot(options?: MLModuleOptions): {
+        module: typeof MLModule;
+        providers: unknown[];
+        exports: unknown[];
+    };
+    static getOptions(): MLModuleOptions;
+}
+//# sourceMappingURL=ml.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ml.module.d.ts","sourceRoot":"","sources":["../src/ml.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,IAAI,EAAE,MAAM,eAAe,CAAC;AAUtF,eAAO,MAAM,SAAS,eAA4B,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;CAC1B;AAkCD,qBAkBa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAC,OAAO,CAAuB;IAE7C;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,eAAoB,GAAG;QAC7C,MAAM,EAAE,OAAO,QAAQ,CAAC;QACxB,SAAS,EAAE,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB;IA8BD,MAAM,CAAC,UAAU,IAAI,eAAe;CAGrC"}

package/dist/ml.module.js

@@ -0,0 +1,126 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MLModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLModule = exports.ML_MODELS = void 0;
+const core_1 = require("@hazeljs/core");
+const model_registry_1 = require("./registry/model.registry");
+const trainer_service_1 = require("./training/trainer.service");
+const pipeline_service_1 = require("./training/pipeline.service");
+const predictor_service_1 = require("./inference/predictor.service");
+const batch_service_1 = require("./inference/batch.service");
+const metrics_service_1 = require("./evaluation/metrics.service");
+const decorators_1 = require("./decorators");
+exports.ML_MODELS = Symbol('hazel:ml:models');
+/**
+ * Bootstrap that registers models with the registry when instantiated.
+ * Added as a provider when using MLModule.forRoot({ models: [...] }).
+ */
+let MLModelBootstrap = class MLModelBootstrap {
+    constructor(modelRegistry, trainerService, predictorService, modelTypes) {
+        this.modelRegistry = modelRegistry;
+        this.trainerService = trainerService;
+        this.predictorService = predictorService;
+        this.modelTypes = modelTypes;
+        const container = core_1.Container.getInstance();
+        for (const ModelClass of this.modelTypes) {
+            const metadata = (0, decorators_1.getModelMetadata)(ModelClass);
+            if (!metadata)
+                continue;
+            const instance = container.resolve(ModelClass);
+            const trainMethod = this.trainerService.discoverTrainMethod(instance);
+            const predictMethod = this.predictorService.discoverPredictMethod(instance);
+            const registered = {
+                metadata,
+                instance,
+                trainMethod,
+                predictMethod,
+            };
+            this.modelRegistry.register(registered);
+        }
+    }
+};
+MLModelBootstrap = __decorate([
+    (0, core_1.Injectable)(),
+    __param(3, (0, core_1.Inject)(exports.ML_MODELS)),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry,
+        trainer_service_1.TrainerService,
+        predictor_service_1.PredictorService, Array])
+], MLModelBootstrap);
+let MLModule = MLModule_1 = class MLModule {
+    /**
+     * Configure MLModule with models to register
+     *
+     * @example
+     * ```typescript
+     * imports: [
+     *   MLModule.forRoot({
+     *     models: [SentimentModel],
+     *   }),
+     * ]
+     * ```
+     */
+    static forRoot(options = {}) {
+        MLModule_1.options = options;
+        const models = options.models || [];
+        const providers = [
+            model_registry_1.ModelRegistry,
+            trainer_service_1.TrainerService,
+            pipeline_service_1.PipelineService,
+            predictor_service_1.PredictorService,
+            batch_service_1.BatchService,
+            metrics_service_1.MetricsService,
+            ...models,
+            { provide: exports.ML_MODELS, useValue: models },
+            MLModelBootstrap,
+        ];
+        return {
+            module: MLModule_1,
+            providers,
+            exports: [
+                model_registry_1.ModelRegistry,
+                trainer_service_1.TrainerService,
+                pipeline_service_1.PipelineService,
+                predictor_service_1.PredictorService,
+                batch_service_1.BatchService,
+                metrics_service_1.MetricsService,
+            ],
+        };
+    }
+    static getOptions() {
+        return MLModule_1.options;
+    }
+};
+exports.MLModule = MLModule;
+MLModule.options = {};
+exports.MLModule = MLModule = MLModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [
+            model_registry_1.ModelRegistry,
+            trainer_service_1.TrainerService,
+            pipeline_service_1.PipelineService,
+            predictor_service_1.PredictorService,
+            batch_service_1.BatchService,
+            metrics_service_1.MetricsService,
+        ],
+        exports: [
+            model_registry_1.ModelRegistry,
+            trainer_service_1.TrainerService,
+            pipeline_service_1.PipelineService,
+            predictor_service_1.PredictorService,
+            batch_service_1.BatchService,
+            metrics_service_1.MetricsService,
+        ],
+    })
+], MLModule);

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/ml.types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @hazeljs/ml - Type definitions for ML models and operations
+ */
+export type MLFramework = 'tensorflow' | 'onnx' | 'custom';
+export interface ModelMetadata {
+    name: string;
+    version: string;
+    framework: MLFramework;
+    description?: string;
+    tags?: string[];
+}
+export interface TrainingData {
+    [key: string]: unknown;
+}
+export interface TrainingResult {
+    accuracy?: number;
+    loss?: number;
+    metrics?: Record<string, number>;
+    modelPath?: string;
+}
+export interface PredictionResult<T = unknown> {
+    [key: string]: T;
+}
+export interface ModelVersion {
+    version: string;
+    createdAt: Date;
+    path?: string;
+    metrics?: Record<string, number>;
+}
+//# sourceMappingURL=ml.types.d.ts.map

package/dist/ml.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ml.types.d.ts","sourceRoot":"","sources":["../src/ml.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO;IAC3C,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}

package/dist/ml.types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @hazeljs/ml - Type definitions for ML models and operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,21 @@
+import { ModelMetadata, ModelVersion } from '../ml.types';
+export interface RegisteredModel {
+    metadata: ModelMetadata;
+    instance: object;
+    trainMethod?: string;
+    predictMethod?: string;
+}
+/**
+ * Model Registry - Handles model versioning and storage
+ * Integrates with TensorFlow.js, ONNX Runtime for model persistence
+ */
+export declare class ModelRegistry {
+    private models;
+    private versions;
+    register(model: RegisteredModel): void;
+    get(name: string, version?: string): RegisteredModel | undefined;
+    list(): ModelMetadata[];
+    getVersions(name: string): ModelVersion[];
+    unregister(name: string, version: string): boolean;
+}
+//# sourceMappingURL=model.registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.registry.d.ts","sourceRoot":"","sources":["../../src/registry/model.registry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,qBACa,aAAa;IACxB,OAAO,CAAC,MAAM,CAA2C;IACzD,OAAO,CAAC,QAAQ,CAA0C;IAE1D,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IActC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAUhE,IAAI,IAAI,aAAa,EAAE;IAIvB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE;IAIzC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;CAUnD"}

package/dist/registry/model.registry.js

@@ -0,0 +1,64 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRegistry = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Model Registry - Handles model versioning and storage
+ * Integrates with TensorFlow.js, ONNX Runtime for model persistence
+ */
+let ModelRegistry = class ModelRegistry {
+    constructor() {
+        this.models = new Map();
+        this.versions = new Map();
+    }
+    register(model) {
+        const key = `${model.metadata.name}@${model.metadata.version}`;
+        this.models.set(key, model);
+        const versions = this.versions.get(model.metadata.name) || [];
+        versions.push({
+            version: model.metadata.version,
+            createdAt: new Date(),
+        });
+        this.versions.set(model.metadata.name, versions);
+        core_2.default.debug(`Registered model: ${key}`);
+    }
+    get(name, version) {
+        if (version) {
+            return this.models.get(`${name}@${version}`);
+        }
+        // Return latest version
+        const versions = this.versions.get(name) || [];
+        const latest = versions[versions.length - 1];
+        return latest ? this.models.get(`${name}@${latest.version}`) : undefined;
+    }
+    list() {
+        return Array.from(this.models.values()).map((m) => m.metadata);
+    }
+    getVersions(name) {
+        return this.versions.get(name) || [];
+    }
+    unregister(name, version) {
+        const key = `${name}@${version}`;
+        const deleted = this.models.delete(key);
+        if (deleted) {
+            const versions = this.versions.get(name) || [];
+            const filtered = versions.filter((v) => v.version !== version);
+            this.versions.set(name, filtered);
+        }
+        return deleted;
+    }
+};
+exports.ModelRegistry = ModelRegistry;
+exports.ModelRegistry = ModelRegistry = __decorate([
+    (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":""}