@open-core/framework 1.0.2-beta.1 → 1.0.5-beta.1

package/dist/runtime/server/system/managers/binary-process.manager.js

@@ -0,0 +1,312 @@
+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); }
+};
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import { inject, injectable } from 'tsyringe';
+import { v4 as uuid } from 'uuid';
+import { IResourceInfo } from '../../../../adapters/contracts/IResourceInfo';
+import { GLOBAL_CONTAINER } from '../../../../kernel/di/container';
+import { AppError } from '../../../../kernel/error/app.error';
+import { loggers } from '../../../../kernel/logger';
+import { METADATA_KEYS } from '../metadata-server.keys';
+const DEFAULT_TIMEOUT_MS = 15000;
+let BinaryProcessManager = class BinaryProcessManager {
+    resourceInfo;
+    services = new Map();
+    constructor(resourceInfo) {
+        this.resourceInfo = resourceInfo;
+    }
+    register(options, serviceClass) {
+        if (this.services.has(options.name)) {
+            loggers.bootstrap.warn(`[BinaryService] Duplicate service name skipped`, {
+                name: options.name,
+            });
+            return;
+        }
+        const entry = {
+            name: options.name,
+            binary: options.binary,
+            timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            status: 'offline',
+            pending: new Map(),
+            eventHandlers: new Map(),
+            buffer: '',
+            serviceClass,
+        };
+        this.services.set(options.name, entry);
+        loggers.bootstrap.debug(`[BinaryService] Registered service`, {
+            name: options.name,
+            binary: options.binary,
+        });
+        const instance = this.resolveServiceInstance(serviceClass);
+        this.applyBinaryProxies(instance, options);
+        this.registerEventHandlers(entry, instance, options);
+        const binaryPath = this.resolveBinaryPath(options.binary);
+        if (!binaryPath) {
+            entry.status = 'missing';
+            loggers.bootstrap.error(`[BinaryService] Binary not found`, {
+                name: options.name,
+                binary: options.binary,
+            });
+            return;
+        }
+        entry.binaryPath = binaryPath;
+        loggers.bootstrap.debug(`[BinaryService] Resolved binary path`, {
+            name: options.name,
+            path: binaryPath,
+        });
+        this.spawnProcess(entry);
+    }
+    async call(serviceName, action, params, timeoutMs) {
+        const entry = this.services.get(serviceName);
+        if (!entry || entry.status !== 'online' || !entry.process) {
+            throw new AppError('COMMON:UNKNOWN', `[OpenCore] BinaryService '${serviceName}' is not available`, 'server');
+        }
+        const id = uuid();
+        const payload = JSON.stringify({ id, action, params });
+        loggers.bootstrap.debug(`[BinaryService] Calling action`, { service: serviceName, action, id });
+        await this.writeLine(entry, payload);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                entry.pending.delete(id);
+                loggers.bootstrap.error(`[BinaryService] Call timeout`, {
+                    service: serviceName,
+                    action,
+                    id,
+                    timeoutMs: timeoutMs ?? entry.timeoutMs,
+                });
+                reject(new AppError('COMMON:UNKNOWN', `[OpenCore] BinaryService '${serviceName}' call timeout`, 'server'));
+            }, timeoutMs ?? entry.timeoutMs);
+            entry.pending.set(id, {
+                resolve,
+                reject,
+                timeout,
+            });
+        });
+    }
+    resolveServiceInstance(serviceClass) {
+        return GLOBAL_CONTAINER.resolve(serviceClass);
+    }
+    applyBinaryProxies(instance, options) {
+        const proto = Object.getPrototypeOf(instance);
+        const methodNames = Object.getOwnPropertyNames(proto).filter((name) => name !== 'constructor' && typeof instance[name] === 'function');
+        for (const methodName of methodNames) {
+            const metadata = Reflect.getMetadata(METADATA_KEYS.BINARY_CALL, proto, methodName);
+            if (!metadata)
+                continue;
+            const serviceName = metadata.service ?? options.name;
+            instance[methodName] = async (...args) => {
+                return this.call(serviceName, metadata.action, args, metadata.timeoutMs ?? options.timeoutMs);
+            };
+        }
+    }
+    resolveBinaryPath(binary) {
+        const resourceRoot = this.resourceInfo.getCurrentResourcePath();
+        const platform = process.platform;
+        const filename = platform === 'win32' ? `${binary}.exe` : binary;
+        const paths = [
+            path.join(resourceRoot, 'bin', platform, filename),
+            path.join(resourceRoot, 'bin', filename),
+            path.join(resourceRoot, filename),
+        ];
+        for (const p of paths) {
+            if (fs.existsSync(p))
+                return p;
+        }
+        return null;
+    }
+    spawnProcess(entry) {
+        if (!entry.binaryPath) {
+            entry.status = 'missing';
+            return;
+        }
+        const child = spawn(entry.binaryPath, [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        entry.process = child;
+        entry.status = 'online';
+        loggers.bootstrap.debug(`[BinaryService] Process spawned`, { name: entry.name, pid: child.pid });
+        child.stdout.on('data', (chunk) => this.handleStdout(entry, chunk));
+        child.stderr.on('data', (chunk) => {
+            loggers.bootstrap.warn(`[BinaryService] ${entry.name} stderr`, {
+                message: chunk.toString(),
+            });
+        });
+        child.on('exit', (code, signal) => {
+            entry.status = 'offline';
+            this.failPending(entry, `Process exited (code=${code}, signal=${signal})`);
+            loggers.bootstrap.error(`[BinaryService] ${entry.name} exited`, {
+                code,
+                signal,
+            });
+        });
+        child.on('error', (error) => {
+            entry.status = 'offline';
+            this.failPending(entry, error.message);
+            loggers.bootstrap.error(`[BinaryService] ${entry.name} process error`, {
+                error: error.message,
+            });
+        });
+        loggers.bootstrap.info(`[BinaryService] ${entry.name} started`, {
+            binary: entry.binaryPath,
+        });
+    }
+    handleStdout(entry, chunk) {
+        entry.buffer += chunk.toString();
+        let newlineIndex = entry.buffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = entry.buffer.slice(0, newlineIndex);
+            entry.buffer = entry.buffer.slice(newlineIndex + 1);
+            const trimmed = line.trim();
+            if (trimmed) {
+                this.handleResponse(entry, trimmed);
+            }
+            newlineIndex = entry.buffer.indexOf('\n');
+        }
+    }
+    handleResponse(entry, rawLine) {
+        let parsed = null;
+        try {
+            parsed = JSON.parse(rawLine);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                loggers.bootstrap.warn(`[BinaryService] ${entry.name} invalid JSON response`, {
+                    line: rawLine,
+                    error: error.message,
+                });
+            }
+            else {
+                loggers.bootstrap.warn(`[BinaryService] ${entry.name} invalid JSON response`, {
+                    line: rawLine,
+                    error: `unknown error: ${error}`,
+                });
+            }
+            return;
+        }
+        if (parsed?.type === 'event') {
+            this.dispatchEvent(entry, parsed);
+            return;
+        }
+        const response = parsed;
+        if (!response?.id) {
+            loggers.bootstrap.warn(`[BinaryService] ${entry.name} response missing id`, {
+                response,
+            });
+            return;
+        }
+        const pending = entry.pending.get(response.id);
+        if (!pending) {
+            loggers.bootstrap.warn(`[BinaryService] ${entry.name} response without pending request`, {
+                id: response.id,
+                status: response.status,
+            });
+            return;
+        }
+        loggers.bootstrap.debug(`[BinaryService] Received response`, {
+            service: entry.name,
+            id: response.id,
+            status: response.status,
+        });
+        entry.pending.delete(response.id);
+        if (pending.timeout)
+            clearTimeout(pending.timeout);
+        if (response.status === 'ok') {
+            loggers.bootstrap.debug(`[BinaryService] Call success`, {
+                service: entry.name,
+                id: response.id,
+            });
+            pending.resolve(response.result);
+            return;
+        }
+        const message = response.error instanceof Error
+            ? response.error.message
+            : typeof response.error === 'string'
+                ? response.error
+                : 'Binary call failed';
+        loggers.bootstrap.error(`[BinaryService] Call error response`, {
+            service: entry.name,
+            id: response.id,
+            error: response.error,
+            message,
+        });
+        pending.reject(new AppError('COMMON:UNKNOWN', message, 'external', response.error));
+    }
+    failPending(entry, reason) {
+        for (const [id, pending] of entry.pending) {
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+            pending.reject(new AppError('COMMON:UNKNOWN', reason, 'external'));
+            entry.pending.delete(id);
+        }
+    }
+    registerEventHandlers(entry, instance, options) {
+        const proto = Object.getPrototypeOf(instance);
+        const methodNames = Object.getOwnPropertyNames(proto).filter((name) => name !== 'constructor' && typeof instance[name] === 'function');
+        for (const methodName of methodNames) {
+            const metadata = Reflect.getMetadata(METADATA_KEYS.BINARY_EVENT, proto, methodName);
+            if (!metadata)
+                continue;
+            const targetService = metadata.service ?? options.name;
+            if (targetService !== entry.name)
+                continue;
+            entry.eventHandlers.set(metadata.event, instance[methodName].bind(instance));
+            loggers.bootstrap.debug(`[BinaryService] Registered event handler`, {
+                service: entry.name,
+                event: metadata.event,
+                method: methodName,
+            });
+        }
+    }
+    dispatchEvent(entry, message) {
+        const handler = entry.eventHandlers.get(message.event);
+        if (!handler) {
+            loggers.bootstrap.warn(`[BinaryService] ${entry.name} received unhandled event`, {
+                event: message.event,
+            });
+            return;
+        }
+        loggers.bootstrap.debug(`[BinaryService] Dispatching event`, {
+            service: entry.name,
+            event: message.event,
+        });
+        try {
+            handler(message.data);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            loggers.bootstrap.error(`[BinaryService] ${entry.name} event handler error`, {
+                event: message.event,
+                error: errorMessage,
+            });
+        }
+    }
+    async writeLine(entry, payload) {
+        const stdin = entry.process?.stdin;
+        if (!stdin)
+            return;
+        const line = `${payload}\n`;
+        if (!stdin.write(line)) {
+            await once(stdin, 'drain');
+        }
+    }
+};
+BinaryProcessManager = __decorate([
+    injectable(),
+    __param(0, inject(IResourceInfo)),
+    __metadata("design:paramtypes", [IResourceInfo])
+], BinaryProcessManager);
+export { BinaryProcessManager };

package/dist/runtime/server/system/metadata-server.keys.d.ts

@@ -0,0 +1,18 @@
+export declare const METADATA_KEYS: {
+    CONTROLLER: string;
+    COMMAND: string;
+    NET_EVENT: string;
+    NET_RPC: string;
+    TICK: string;
+    INTERNAL_EVENT: string;
+    LIBRARY_EVENT: string;
+    RUNTIME_EVENT: string;
+    EXPORT: string;
+    PUBLIC: string;
+    THROTTLE: string;
+    REQUIRES_STATE: string;
+    BINARY_SERVICE: string;
+    BINARY_SERVICE_NAME: string;
+    BINARY_CALL: string;
+    BINARY_EVENT: string;
+};

package/dist/runtime/server/system/metadata-server.keys.js

@@ -0,0 +1,18 @@
+export const METADATA_KEYS = {
+    CONTROLLER: 'decorator:meta:controller',
+    COMMAND: 'decorator:meta:command',
+    NET_EVENT: 'decorator:meta:net_event',
+    NET_RPC: 'decorator:meta:net_rpc',
+    TICK: 'decorator:meta:tick',
+    INTERNAL_EVENT: 'decorator:meta:internal_event',
+    LIBRARY_EVENT: 'decorator:meta:library_event',
+    RUNTIME_EVENT: 'decorator:meta:runtime_event',
+    EXPORT: 'decorator:meta:export',
+    PUBLIC: 'decorator:meta:public',
+    THROTTLE: 'decorator:throttle',
+    REQUIRES_STATE: 'decorator:requires_state',
+    BINARY_SERVICE: 'decorator:meta:binary_service',
+    BINARY_SERVICE_NAME: 'decorator:meta:binary_service_name',
+    BINARY_CALL: 'decorator:meta:binary_call',
+    BINARY_EVENT: 'decorator:meta:binary_event',
+};

package/dist/runtime/server/system/processors/command.processor.d.ts

@@ -0,0 +1,16 @@
+import { DecoratorProcessor } from '../../../../kernel/di/index';
+import { CommandMetadata } from '../../decorators/command';
+import { CommandExecutionPort } from '../../ports/internal/command-execution.port';
+/**
+ * Processor for @Command decorator.
+ *
+ * @remarks
+ * Reads command metadata and registers handlers with CommandExecutionPort.
+ * The port implementation (local or remote) depends on runtime mode.
+ */
+export declare class CommandProcessor implements DecoratorProcessor {
+    private commandService;
+    readonly metadataKey: string;
+    constructor(commandService: CommandExecutionPort);
+    process(target: any, methodName: string, metadata: CommandMetadata): void;
+}

package/dist/runtime/server/system/processors/command.processor.js

@@ -0,0 +1,62 @@
+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); }
+};
+import { inject, injectable } from 'tsyringe';
+import { CommandExecutionPort } from '../../ports/internal/command-execution.port';
+import { METADATA_KEYS } from '../metadata-server.keys';
+/**
+ * Processor for @Command decorator.
+ *
+ * @remarks
+ * Reads command metadata and registers handlers with CommandExecutionPort.
+ * The port implementation (local or remote) depends on runtime mode.
+ */
+let CommandProcessor = class CommandProcessor {
+    commandService;
+    metadataKey = METADATA_KEYS.COMMAND;
+    constructor(commandService) {
+        this.commandService = commandService;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        // Check if method has @Public decorator
+        const proto = Object.getPrototypeOf(target);
+        const isPublic = Reflect.getMetadata(METADATA_KEYS.PUBLIC, proto, methodName);
+        // Collect security metadata from decorators
+        const guardOptions = Reflect.getMetadata('core:guard', proto, methodName);
+        const throttleOptions = Reflect.getMetadata(METADATA_KEYS.THROTTLE, proto, methodName);
+        const requiresStateOptions = Reflect.getMetadata(METADATA_KEYS.REQUIRES_STATE, proto, methodName);
+        // Build security metadata if any decorator is present
+        const security = guardOptions || throttleOptions || requiresStateOptions
+            ? {
+                guard: guardOptions,
+                throttle: throttleOptions,
+                requiresState: requiresStateOptions,
+            }
+            : undefined;
+        const normalizedCommand = metadata.command.trim().replace(/^\/+/, '');
+        // Enrich metadata with isPublic flag and security
+        const enrichedMetadata = {
+            ...metadata,
+            command: normalizedCommand,
+            isPublic: isPublic ?? false,
+            security,
+        };
+        this.commandService.register(enrichedMetadata, handler);
+    }
+};
+CommandProcessor = __decorate([
+    injectable(),
+    __param(0, inject(CommandExecutionPort)),
+    __metadata("design:paramtypes", [CommandExecutionPort])
+], CommandProcessor);
+export { CommandProcessor };

package/dist/runtime/server/system/processors/export.processor.d.ts

@@ -0,0 +1,10 @@
+import { IExports } from '../../../../adapters/contracts/IExports';
+import { type DecoratorProcessor } from '../../../../kernel/di/index';
+export declare class ExportProcessor implements DecoratorProcessor {
+    private exportsService;
+    readonly metadataKey: string;
+    constructor(exportsService: IExports);
+    process(instance: any, methodName: string, metadata: {
+        exportName: string;
+    }): void;
+}

package/dist/runtime/server/system/processors/export.processor.js

@@ -0,0 +1,38 @@
+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); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IExports } from '../../../../adapters/contracts/IExports';
+import { loggers } from '../../../../kernel/logger';
+import { resolveMethod } from '../../helpers/resolve-method';
+import { METADATA_KEYS } from '../metadata-server.keys';
+let ExportProcessor = class ExportProcessor {
+    exportsService;
+    metadataKey = METADATA_KEYS.EXPORT;
+    constructor(exportsService) {
+        this.exportsService = exportsService;
+    }
+    process(instance, methodName, metadata) {
+        const result = resolveMethod(instance, methodName, `[ExportEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler } = result;
+        this.exportsService.register(metadata.exportName, handler);
+        loggers.exports.debug(`Registered: ${metadata.exportName}`);
+    }
+};
+ExportProcessor = __decorate([
+    injectable(),
+    __param(0, inject(IExports)),
+    __metadata("design:paramtypes", [IExports])
+], ExportProcessor);
+export { ExportProcessor };

package/dist/runtime/server/system/processors/internalEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+export declare class InternalEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(instance: any, methodName: string, metadata: {
+        event: string;
+    }): void;
+}

package/dist/runtime/server/system/processors/internalEvent.processor.js

@@ -0,0 +1,36 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { loggers } from '../../../../kernel/logger';
+import { onFrameworkEvent } from '../../bus/internal-event.bus';
+import { resolveMethod } from '../../helpers/resolve-method';
+import { METADATA_KEYS } from '../metadata-server.keys';
+let InternalEventProcessor = class InternalEventProcessor {
+    metadataKey = METADATA_KEYS.INTERNAL_EVENT;
+    process(instance, methodName, metadata) {
+        const result = resolveMethod(instance, methodName, `[InternalEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName } = result;
+        onFrameworkEvent(metadata.event, (payload) => {
+            try {
+                handler(payload);
+            }
+            catch (error) {
+                loggers.eventBus.error(`Handler error in InternalEvent`, {
+                    event: metadata.event,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        loggers.eventBus.debug(`Registered: ${metadata.event} -> ${handlerName}`);
+    }
+};
+InternalEventProcessor = __decorate([
+    injectable()
+], InternalEventProcessor);
+export { InternalEventProcessor };

package/dist/runtime/server/system/processors/libraryEvent.processor.d.ts

@@ -0,0 +1,6 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { LibraryEventDecoratorMetadata } from '../../decorators/onLibraryEvent';
+export declare class LibraryEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(instance: any, methodName: string, metadata: LibraryEventDecoratorMetadata): void;
+}

package/dist/runtime/server/system/processors/libraryEvent.processor.js

@@ -0,0 +1,38 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { loggers } from '../../../../kernel/logger';
+import { onLibraryEvent } from '../../bus/library-event.bus';
+import { resolveMethod } from '../../helpers/resolve-method';
+import { METADATA_KEYS } from '../metadata-server.keys';
+let LibraryEventProcessor = class LibraryEventProcessor {
+    metadataKey = METADATA_KEYS.LIBRARY_EVENT;
+    process(instance, methodName, metadata) {
+        const result = resolveMethod(instance, methodName, `[LibraryEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName } = result;
+        onLibraryEvent(metadata.eventId, (event) => {
+            try {
+                return handler(event.payload, event.meta);
+            }
+            catch (error) {
+                loggers.eventBus.error(`Handler error in LibraryEvent`, {
+                    eventId: metadata.eventId,
+                    libraryName: metadata.libraryName,
+                    eventName: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        loggers.eventBus.debug(`Registered: ${metadata.eventId} -> ${handlerName}`);
+    }
+};
+LibraryEventProcessor = __decorate([
+    injectable()
+], LibraryEventProcessor);
+export { LibraryEventProcessor };

package/dist/runtime/server/system/processors/netEvent.processor.d.ts

@@ -0,0 +1,23 @@
+import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
+import { type DecoratorProcessor } from '../../../../kernel/di/index';
+import { NetEventSecurityObserverContract } from '../../contracts/security/net-event-security-observer.contract';
+import { SecurityHandlerContract } from '../../contracts/security/security-handler.contract';
+import { NetEventOptions } from '../../decorators';
+import { Players } from '../../ports/players.api-port';
+export declare class NetEventProcessor implements DecoratorProcessor {
+    private playerService;
+    private securityHandler;
+    private netEventObserver;
+    private events;
+    readonly metadataKey: string;
+    private readonly INVALID_COUNTS_META_KEY;
+    constructor(playerService: Players, securityHandler: SecurityHandlerContract, netEventObserver: NetEventSecurityObserverContract, events: EventsAPI<'server'>);
+    process(instance: any, methodName: string, metadata: NetEventOptions): void;
+    private safeHandleViolation;
+    private reasonFromSecurityError;
+    private handleInvalidPayload;
+    private incrementInvalidCount;
+    private summarizeZodError;
+    private safeObserve;
+    private getExpectedArgsCount;
+}