@hazeljs/ml 0.2.0-beta.37

package/dist/inference/batch.service.js

@@ -0,0 +1,47 @@
+"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 = [];
+        const batches = [];
+        for (let i = 0; i < inputs.length; i += batchSize) {
+            batches.push(inputs.slice(i, i + batchSize));
+        }
+        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) => this.predictorService.predict(modelName, input, version))));
+            results.push(...batchResults);
+        }
+        return results;
+    }
+};
+exports.BatchService = BatchService;
+exports.BatchService = BatchService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [predictor_service_1.PredictorService])
+], BatchService);

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.Injectable)(),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry])
+], PredictorService);

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.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.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.Injectable)()
+], ModelRegistry);

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

@@ -0,0 +1,17 @@
+import { TrainingData } from '../ml.types';
+export interface PipelineStep {
+    name: string;
+    transform: (data: unknown) => Promise<unknown> | unknown;
+}
+/**
+ * Pipeline Service - ETL pipelines for training data preparation
+ * Handles data transformation before model training
+ */
+export declare class PipelineService {
+    private pipelines;
+    registerPipeline(name: string, steps: PipelineStep[]): void;
+    run(name: string, data: TrainingData): Promise<TrainingData>;
+    getPipeline(name: string): PipelineStep[] | undefined;
+    listPipelines(): string[];
+}
+//# sourceMappingURL=pipeline.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.service.d.ts","sourceRoot":"","sources":["../../src/training/pipeline.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC1D;AAED;;;GAGG;AACH,qBACa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAA0C;IAE3D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAKrD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAelE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,SAAS;IAIrD,aAAa,IAAI,MAAM,EAAE;CAG1B"}

package/dist/training/pipeline.service.js

@@ -0,0 +1,49 @@
+"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.PipelineService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Pipeline Service - ETL pipelines for training data preparation
+ * Handles data transformation before model training
+ */
+let PipelineService = class PipelineService {
+    constructor() {
+        this.pipelines = new Map();
+    }
+    registerPipeline(name, steps) {
+        this.pipelines.set(name, steps);
+        core_2.default.debug(`Registered pipeline: ${name} with ${steps.length} steps`);
+    }
+    async run(name, data) {
+        const steps = this.pipelines.get(name);
+        if (!steps) {
+            throw new Error(`Pipeline not found: ${name}`);
+        }
+        let result = data;
+        for (const step of steps) {
+            core_2.default.debug(`Pipeline ${name}: executing step ${step.name}`);
+            result = await Promise.resolve(step.transform(result));
+        }
+        return result;
+    }
+    getPipeline(name) {
+        return this.pipelines.get(name);
+    }
+    listPipelines() {
+        return Array.from(this.pipelines.keys());
+    }
+};
+exports.PipelineService = PipelineService;
+exports.PipelineService = PipelineService = __decorate([
+    (0, core_1.Injectable)()
+], PipelineService);

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

@@ -0,0 +1,13 @@
+import { ModelRegistry } from '../registry/model.registry';
+import { TrainingData, TrainingResult } from '../ml.types';
+/**
+ * Trainer Service - Training orchestration for ML models
+ * Coordinates training pipelines and model updates
+ */
+export declare class TrainerService {
+    private readonly modelRegistry;
+    constructor(modelRegistry: ModelRegistry);
+    train(modelName: string, data: TrainingData, version?: string): Promise<TrainingResult>;
+    discoverTrainMethod(instance: object): string | undefined;
+}
+//# sourceMappingURL=trainer.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trainer.service.d.ts","sourceRoot":"","sources":["../../src/training/trainer.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG3D;;;GAGG;AACH,qBACa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEnD,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA2B7F,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAgB1D"}

package/dist/training/trainer.service.js

@@ -0,0 +1,69 @@
+"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.TrainerService = 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"));
+/**
+ * Trainer Service - Training orchestration for ML models
+ * Coordinates training pipelines and model updates
+ */
+let TrainerService = class TrainerService {
+    constructor(modelRegistry) {
+        this.modelRegistry = modelRegistry;
+    }
+    async train(modelName, data, version) {
+        const model = this.modelRegistry.get(modelName, version);
+        if (!model) {
+            throw new Error(`Model not found: ${modelName}`);
+        }
+        const trainMethod = model.trainMethod;
+        if (!trainMethod) {
+            throw new Error(`Model ${modelName} has no training method`);
+        }
+        const instance = model.instance;
+        const trainFn = instance[trainMethod];
+        if (typeof trainFn !== 'function') {
+            throw new Error(`Training method ${trainMethod} not found on model`);
+        }
+        core_2.default.debug(`Starting training for model: ${modelName}`);
+        const result = await trainFn.call(instance, data);
+        core_2.default.debug(`Training completed for model: ${modelName}`, result);
+        return result;
+    }
+    discoverTrainMethod(instance) {
+        const metadata = (0, decorators_1.getModelMetadata)(instance.constructor);
+        if (!metadata)
+            return undefined;
+        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.getTrainMetadata)(proto, key)) {
+                    return key;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+exports.TrainerService = TrainerService;
+exports.TrainerService = TrainerService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry])
+], TrainerService);