@open-core/framework 0.1.0-alpha.1 → 0.2.1-beta.1

package/dist/{client → runtime/client}/types/game-events.js

@@ -1,12 +1,4 @@
 "use strict";
-/**
- * Game Events - Native GTA V internal events captured by FiveM
- *
- * Documentation: https://docs.fivem.net/docs/game-references/game-events/
- *
- * These are low-level events from the RAGE engine. The arguments are
- * passed as arrays from the native layer.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GameEventParsers = void 0;
 // ─────────────────────────────────────────────────────────────────────────────

package/dist/{client → runtime/client}/ui-bridge.js

@@ -8,7 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NUI = exports.NuiBridge = void 0;
 const tsyringe_1 = require("tsyringe");
-const logger_1 = require("../shared/logger");
+const logger_1 = require("../../kernel/shared/logger");
 const nuiLogger = logger_1.coreLogger.child('NUI', logger_1.LogDomain.CLIENT);
 /**
  * Type-safe NUI (Native UI) Bridge for client-server communication.

package/dist/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * as Client from './client';
+export * as Server from './server';

package/dist/runtime/index.js

@@ -0,0 +1,39 @@
+"use strict";
+// Runtime - System execution
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = exports.Client = void 0;
+exports.Client = __importStar(require("./client"));
+exports.Server = __importStar(require("./server"));

package/dist/{server → runtime/server}/bootstrap.d.ts

@@ -1,3 +1,4 @@
+import { type ServerRuntimeOptions } from './runtime';
 /**
  * Bootstraps the OpenCore Server Application Context.
  *
@@ -13,4 +14,4 @@
  *
  * @returns A promise that resolves when the Core is fully initialized and ready to process events.
  */
-export declare function initServer(): Promise<void>;
+export declare function initServer(options: ServerRuntimeOptions): Promise<void>;

package/dist/runtime/server/bootstrap.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initServer = initServer;
+const register_capabilities_1 = require("../../adapters/register-capabilities");
+const index_1 = require("../../kernel/di/index");
+const logger_1 = require("../../kernel/shared/logger");
+const index_2 = require("./contracts/index");
+const bootstrap_validation_1 = require("./bootstrap.validation");
+const controller_1 = require("./decorators/controller");
+const runtime_1 = require("./runtime");
+const services_register_1 = require("./services/services.register");
+const processors_register_1 = require("./system/processors.register");
+function checkProviders(ctx) {
+    if (ctx.mode === 'RESOURCE')
+        return;
+    if (ctx.features.principal.enabled && ctx.features.principal.required) {
+        if (!index_1.di.isRegistered(index_2.PrincipalProviderContract)) {
+            const errorMsg = 'No Principal Provider configured. ' +
+                "Please call 'Server.setPrincipalProvider(YourProvider)' before init(). This is required for authorization.";
+            logger_1.loggers.bootstrap.fatal(errorMsg);
+            throw new Error(`[OpenCore] CRITICAL: ${errorMsg}`);
+        }
+    }
+    if (ctx.features.auth.enabled && ctx.features.auth.required) {
+        if (!index_1.di.isRegistered(index_2.AuthProviderContract)) {
+            const errorMsg = 'No Authentication Provider configured. ' +
+                "Please call 'Server.setAuthProvider(YourProvider)' before init(). This is required for authentication.";
+            logger_1.loggers.bootstrap.fatal(errorMsg);
+            throw new Error(`[OpenCore] CRITICAL: ${errorMsg}`);
+        }
+    }
+}
+async function loadFrameworkControllers(ctx) {
+    if (ctx.features.commands.enabled) {
+        if (ctx.mode === 'RESOURCE') {
+            // RESOURCE mode: only load the controller that receives delegated commands from CORE
+            await Promise.resolve().then(() => __importStar(require('./controllers/remote-command-execution.controller')));
+        }
+        else {
+            // CORE/STANDALONE mode: load the unified command controller
+            // This handles both network events and exports in a single controller
+            await Promise.resolve().then(() => __importStar(require('./controllers/command-export.controller')));
+        }
+    }
+    if (ctx.features.chat.enabled && ctx.features.chat.export && ctx.features.exports.enabled) {
+        if (ctx.mode !== 'RESOURCE') {
+            await Promise.resolve().then(() => __importStar(require('./controllers/chat.controller')));
+        }
+    }
+    if (ctx.features.sessionLifecycle.enabled && ctx.mode !== 'RESOURCE') {
+        await Promise.resolve().then(() => __importStar(require('./controllers/session.controller')));
+    }
+    if (ctx.features.players.enabled && ctx.features.players.export && ctx.features.exports.enabled) {
+        await Promise.resolve().then(() => __importStar(require('./controllers/player-export.controller')));
+    }
+    if (ctx.features.principal.enabled &&
+        ctx.features.principal.export &&
+        ctx.features.exports.enabled) {
+        await Promise.resolve().then(() => __importStar(require('./controllers/principal-export.controller')));
+    }
+}
+/**
+ * Bootstraps the OpenCore Server Application Context.
+ *
+ * This is the primary entry point for the server-side framework. It orchestrates the
+ * initialization of the Dependency Injection (DI) container and establishes the
+ * bridge between the low-level FiveM runtime and the OpenCore architecture.
+ *
+ * **Initialization Lifecycle:**
+ * 1. **Infrastructure Registration:** Registers core infrastructure services (`PlayerService`, `CommandService`, `HttpService`) as Singletons in the IoC container.
+ * 2. **Reflection & Discovery:** Scans all decorated classes (Controllers, Services) to extract metadata defined by `@Command`, `@OnNet`, etc.
+ * 3. **Runtime Binding:** Binds the discovered metadata to actual FiveM natives (e.g., `RegisterCommand`, `onNet`, `exports`).
+ * 4. **Session Management:** Activates the player session tracking system.
+ *
+ * @returns A promise that resolves when the Core is fully initialized and ready to process events.
+ */
+async function initServer(options) {
+    var _a;
+    (0, runtime_1.validateRuntimeOptions)(options);
+    (0, runtime_1.setRuntimeContext)(options);
+    const ctx = options;
+    logger_1.loggers.bootstrap.info('Initializing OpenCore Server...');
+    logger_1.loggers.bootstrap.debug('Runtime configuration', {
+        mode: ctx.mode,
+        scope: (0, runtime_1.getFrameworkModeScope)(ctx.mode),
+    });
+    await (0, register_capabilities_1.registerServerCapabilities)();
+    (0, services_register_1.registerServicesServer)(ctx);
+    logger_1.loggers.bootstrap.debug('Core services registered');
+    (0, processors_register_1.registerSystemServer)(ctx);
+    logger_1.loggers.bootstrap.debug('System processors registered');
+    checkProviders(ctx);
+    // In RESOURCE mode, verify CORE exports are available before loading controllers
+    if (ctx.mode === 'RESOURCE') {
+        const needsCoreExports = ctx.features.players.provider === 'core' ||
+            ctx.features.commands.provider === 'core' ||
+            ctx.features.principal.provider === 'core' ||
+            ctx.features.auth.provider === 'core';
+        if (needsCoreExports) {
+            const { coreResourceName } = ctx;
+            logger_1.loggers.bootstrap.debug(`Verifying CORE exports availability`, {
+                coreResourceName,
+                globalExportsKeys: Object.keys(globalThis.exports || {}),
+            });
+            // Build list of required exports
+            const requiredExports = [];
+            if (ctx.features.commands.provider === 'core') {
+                requiredExports.push('registerCommand', 'executeCommand', 'getAllCommands');
+            }
+            if (ctx.features.players.provider === 'core') {
+                requiredExports.push('getPlayerId', 'getPlayerData', 'getAllPlayersData', 'getPlayerByAccountId', 'getPlayerCount', 'isPlayerOnline', 'getPlayerMeta', 'setPlayerMeta', 'getPlayerStates', 'hasPlayerState', 'addPlayerState', 'removePlayerState');
+            }
+            if (ctx.features.principal.provider === 'core') {
+                requiredExports.push('getPrincipal', 'getPrincipalByAccountId', 'refreshPrincipal', 'hasPermission', 'hasRank', 'hasAnyPermission', 'hasAllPermissions', 'getPermissions', 'getRank', 'getPrincipalName', 'getPrincipalMeta');
+            }
+            logger_1.loggers.bootstrap.debug(`Checking CORE exports`, {
+                coreResourceName,
+                requiredExports,
+            });
+            // Access exports directly using FiveM's global exports object
+            const globalExports = globalThis.exports;
+            if (!globalExports) {
+                throw new Error(`[OpenCore] FiveM 'exports' global not found. This should never happen in a FiveM environment.`);
+            }
+            const coreExports = globalExports[coreResourceName];
+            // Check each required export directly (can't use Object.keys on FiveM exports proxy)
+            const missingExports = [];
+            for (const exportName of requiredExports) {
+                try {
+                    const exportValue = coreExports === null || coreExports === void 0 ? void 0 : coreExports[exportName];
+                    if (typeof exportValue !== 'function') {
+                        missingExports.push(exportName);
+                        logger_1.loggers.bootstrap.warn(`Export '${exportName}' is not a function`, {
+                            exportName,
+                            type: typeof exportValue,
+                            value: exportValue,
+                        });
+                    }
+                }
+                catch (error) {
+                    missingExports.push(exportName);
+                    logger_1.loggers.bootstrap.warn(`Failed to access export '${exportName}'`, {
+                        exportName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            if (missingExports.length > 0) {
+                const errorMsg = `CORE resource '${coreResourceName}' is missing ${missingExports.length} required exports: ${missingExports.join(', ')}\n` +
+                    `\n` +
+                    `This usually means:\n` +
+                    `  1. The CORE resource failed to initialize properly\n` +
+                    `  2. The CORE resource doesn't have the 'exports' feature enabled\n` +
+                    `  3. The CORE resource doesn't have the required features enabled (commands: ${ctx.features.commands.provider === 'core'})\n` +
+                    `\n` +
+                    `Verify in '${coreResourceName}/src/server/server.ts':\n` +
+                    `  - mode: 'CORE'\n` +
+                    `  - features.exports.enabled: true\n` +
+                    `  - features.commands.enabled: true (if using commands)`;
+                logger_1.loggers.bootstrap.fatal(errorMsg);
+                throw new Error(`[OpenCore] ${errorMsg}`);
+            }
+        }
+    }
+    await loadFrameworkControllers(ctx);
+    if (ctx.features.database.enabled) {
+        (0, bootstrap_validation_1.registerDefaultBootstrapValidators)();
+        await (0, bootstrap_validation_1.runBootstrapValidatorsOrThrow)();
+    }
+    const scanner = index_1.di.resolve(index_1.MetadataScanner);
+    scanner.scan((0, controller_1.getServerControllerRegistry)());
+    // Initialize DevMode if enabled
+    if ((_a = ctx.devMode) === null || _a === void 0 ? void 0 : _a.enabled) {
+        await initDevMode(ctx.devMode);
+    }
+    logger_1.loggers.bootstrap.info('OpenCore Server initialized successfully');
+}
+/**
+ * Initializes the DevMode subsystem.
+ * This is loaded dynamically to avoid bundling dev tools in production.
+ */
+async function initDevMode(config) {
+    const { DevModeService } = await Promise.resolve().then(() => __importStar(require('./devmode/dev-mode.service')));
+    const { EventInterceptorService } = await Promise.resolve().then(() => __importStar(require('./devmode/event-interceptor.service')));
+    const { StateInspectorService } = await Promise.resolve().then(() => __importStar(require('./devmode/state-inspector.service')));
+    const { PlayerSimulatorService } = await Promise.resolve().then(() => __importStar(require('./devmode/player-simulator.service')));
+    // Register DevMode services
+    index_1.di.registerSingleton(EventInterceptorService, EventInterceptorService);
+    index_1.di.registerSingleton(StateInspectorService, StateInspectorService);
+    index_1.di.registerSingleton(PlayerSimulatorService, PlayerSimulatorService);
+    index_1.di.registerSingleton(DevModeService, DevModeService);
+    // Enable DevMode
+    const devModeService = index_1.di.resolve(DevModeService);
+    await devModeService.enable({
+        enabled: true,
+        hotReload: config.hotReload,
+        bridge: config.bridge,
+        interceptor: config.interceptor,
+        simulator: config.simulator,
+    });
+}

package/dist/runtime/server/bootstrap.validation.d.ts

@@ -0,0 +1,12 @@
+export type BootstrapValidator = () => string[] | Promise<string[]>;
+/**
+ * Register a bootstrap validator.
+ *  This is only used for cases of custom validators or resources that require validation,
+ *  like Driver resources.
+ *
+ * @param name - The name of the validator.
+ * @param validator - The validator function.
+ */
+export declare function registerBootstrapValidator(name: string, validator: BootstrapValidator): void;
+export declare function runBootstrapValidatorsOrThrow(): Promise<void>;
+export declare function registerDefaultBootstrapValidators(): void;

package/dist/runtime/server/bootstrap.validation.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBootstrapValidator = registerBootstrapValidator;
+exports.runBootstrapValidatorsOrThrow = runBootstrapValidatorsOrThrow;
+exports.registerDefaultBootstrapValidators = registerDefaultBootstrapValidators;
+const zod_1 = require("zod");
+const logger_1 = require("../../kernel/shared/logger");
+const validators = new Map();
+/**
+ * Register a bootstrap validator.
+ *  This is only used for cases of custom validators or resources that require validation,
+ *  like Driver resources.
+ *
+ * @param name - The name of the validator.
+ * @param validator - The validator function.
+ */
+function registerBootstrapValidator(name, validator) {
+    if (validators.has(name)) {
+        throw new Error(`[OpenCore] Bootstrap validator '${name}' is already registered`);
+    }
+    validators.set(name, validator);
+}
+async function runBootstrapValidatorsOrThrow() {
+    const allErrors = [];
+    for (const [name, validator] of validators.entries()) {
+        const errors = await validator();
+        for (const err of errors)
+            allErrors.push(`[${name}] ${err}`);
+    }
+    if (allErrors.length === 0)
+        return;
+    const message = ['Invalid configuration detected during bootstrap:', ...allErrors].join('\n');
+    logger_1.loggers.bootstrap.fatal(message);
+    throw new Error(`[OpenCore] CRITICAL: ${message}`);
+}
+function getBooleanConvar(name, defaultValue = false) {
+    const raw = GetConvar(name, defaultValue ? 'true' : 'false')
+        .toLowerCase()
+        .trim();
+    return raw === 'true' || raw === '1' || raw === 'yes' || raw === 'y';
+}
+function getOptionalStringConvar(name) {
+    const raw = GetConvar(name, '').trim();
+    return raw.length > 0 ? raw : undefined;
+}
+function zodIssuesToLines(prefix, error) {
+    return error.issues.map((i) => {
+        const path = i.path.length ? `${prefix}.${i.path.join('.')}` : prefix;
+        return `${path}: ${i.message}`;
+    });
+}
+const PersistenceSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    adapter: zod_1.z.string().min(1).optional(),
+    resourceName: zod_1.z.string().min(1).optional(),
+})
+    .superRefine((val, ctx) => {
+    if (!val.enabled)
+        return;
+    if (!val.adapter) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'Required when opencore_persistence_enabled=true (set opencore_db_adapter)',
+        });
+        return;
+    }
+    if (val.adapter === 'resource' && !val.resourceName) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['resourceName'],
+            message: 'Required when opencore_db_adapter=resource (set opencore_db_resource)',
+        });
+    }
+});
+function validatePersistence() {
+    const enabled = getBooleanConvar('opencore_persistence_enabled', false);
+    if (!enabled)
+        return [];
+    const adapter = getOptionalStringConvar('opencore_db_adapter');
+    const resourceName = getOptionalStringConvar('opencore_db_resource');
+    const parsed = PersistenceSchema.safeParse({ enabled, adapter, resourceName });
+    if (!parsed.success)
+        return zodIssuesToLines('persistence', parsed.error);
+    if (adapter === 'resource') {
+        const db = exports[resourceName];
+        if (!db) {
+            return [
+                `persistence.resource: Database resource '${resourceName}' is not available. Start it before this resource.`,
+            ];
+        }
+    }
+    return [];
+}
+let defaultsRegistered = false;
+function registerDefaultBootstrapValidators() {
+    if (defaultsRegistered)
+        return;
+    registerBootstrapValidator('persistence', validatePersistence);
+    defaultsRegistered = true;
+}

package/dist/runtime/server/bus/core-event-bus.d.ts

@@ -0,0 +1,6 @@
+import { CoreEventMap } from '../types/core-events';
+type CoreEventName = keyof CoreEventMap;
+type CoreEventHandler<E extends CoreEventName> = (payload: CoreEventMap[E]) => void;
+export declare function onFrameworkEvent<E extends CoreEventName>(event: E, handler: CoreEventHandler<E>): () => void;
+export declare function emitFrameworkEvent<E extends CoreEventName>(event: E, payload: CoreEventMap[E]): void;
+export {};

package/dist/{server → runtime/server}/bus/core-event-bus.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onCoreEvent = onCoreEvent;
-exports.emitCoreEvent = emitCoreEvent;
-const logger_1 = require("../../shared/logger");
+exports.onFrameworkEvent = onFrameworkEvent;
+exports.emitFrameworkEvent = emitFrameworkEvent;
+const logger_1 = require("../../../kernel/shared/logger");
 const handlers = {};
-function onCoreEvent(event, handler) {
+function onFrameworkEvent(event, handler) {
     var _a;
     const list = ((_a = handlers[event]) !== null && _a !== void 0 ? _a : (handlers[event] = []));
     list.push(handler);
@@ -14,7 +14,7 @@ function onCoreEvent(event, handler) {
             list.splice(index, 1);
     };
 }
-function emitCoreEvent(event, payload) {
+function emitFrameworkEvent(event, payload) {
     const list = handlers[event];
     if (!list)
         return;

package/dist/{server → runtime/server}/configs/api.config.d.ts

@@ -1,4 +1,4 @@
-import { FluentConfigurator } from './config.base';
+import { type FluentConfigurator } from './config.base';
 interface ApiConfigState {
     baseUrl: string;
     timeoutMs: number;

package/dist/{server/templates/auth → runtime/server/contracts}/auth-provider.contract.d.ts

@@ -1,5 +1,5 @@
-import type { LinkedID } from '../../services';
-import type { Server } from '../../..';
+import { Server } from '../../..';
+import { LinkedID } from '../services/types/linked-id';
 export interface AuthCredentials {
     /** Standard username/password auth */
     username?: string;

package/dist/runtime/server/contracts/index.d.ts

@@ -0,0 +1,7 @@
+export * from './auth-provider.contract';
+export * from './player-persistence.contract';
+export * from './repository/index';
+export * from './security/net-event-security-observer.contract';
+export * from './security/permission.types';
+export * from './security/principal-provider.contract';
+export * from './security/security-handler.contract';

package/dist/{server/templates → runtime/server/contracts}/index.js

@@ -1,4 +1,5 @@
 "use strict";
+// Security
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,8 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// Abstract templates and contracts
+__exportStar(require("./auth-provider.contract"), exports);
+__exportStar(require("./player-persistence.contract"), exports);
+// Repository
+__exportStar(require("./repository/index"), exports);
+__exportStar(require("./security/net-event-security-observer.contract"), exports);
+__exportStar(require("./security/permission.types"), exports);
 __exportStar(require("./security/principal-provider.contract"), exports);
-__exportStar(require("./repository"), exports);
-__exportStar(require("./persistence"), exports);
-__exportStar(require("./auth/auth-provider.contract"), exports);
+__exportStar(require("./security/security-handler.contract"), exports);

package/dist/{server/templates/persistence → runtime/server/contracts}/player-persistence.contract.d.ts

@@ -1,4 +1,4 @@
-import type { Player } from '../../entities/player';
+import { Player } from '../entities';
 /**
  * Configuration for player data persistence behavior.
  */

package/dist/{server/templates → runtime/server/contracts}/repository/index.d.ts

@@ -7,7 +7,7 @@
  * @example
  * ```typescript
  * import { Repository, FindOptions } from '@open-core/framework/server'
- * import type { DatabaseContract } from '@open-core/framework/server'
+ * import { DatabaseContract } from '@open-core/framework/server'
  *
  * interface User {
  *   id: number
@@ -53,5 +53,5 @@
  * }
  * ```
  */
-export type { OrderDirection, FindOptions, FindManyResult, WhereCondition, } from './repository.types';
 export { Repository } from './repository.contract';
+export type { FindManyResult, FindOptions, OrderDirection, WhereCondition, } from './repository.types';

package/dist/{server/templates → runtime/server/contracts}/repository/index.js

@@ -8,7 +8,7 @@
  * @example
  * ```typescript
  * import { Repository, FindOptions } from '@open-core/framework/server'
- * import type { DatabaseContract } from '@open-core/framework/server'
+ * import { DatabaseContract } from '@open-core/framework/server'
  *
  * interface User {
  *   id: number

package/dist/{server/templates → runtime/server/contracts}/repository/repository.contract.d.ts

@@ -45,8 +45,8 @@
  * const users = await userRepo.findMany({ active: true }, { limit: 10, orderBy: { createdAt: 'DESC' } })
  * ```
  */
-import type { DatabaseContract } from '../../database/database.contract';
-import type { FindOptions, FindManyResult, WhereCondition, OrderDirection } from './repository.types';
+import { DatabaseContract } from '../../database/database.contract';
+import { FindManyResult, FindOptions, OrderDirection, WhereCondition } from './repository.types';
 /**
  * Abstract Repository base class
  *

package/dist/{server/templates → runtime/server/contracts}/repository/repository.contract.js

@@ -295,7 +295,6 @@ class Repository {
                 conditions.push(`${key} IS NULL`);
             }
             else if (value === undefined) {
-                continue; // Skip undefined values
             }
             else {
                 conditions.push(`${key} = ?`);

package/dist/runtime/server/contracts/security/net-event-security-observer.contract.d.ts

@@ -0,0 +1,15 @@
+import { Player } from '../../entities/player';
+export type NetEventInvalidPayloadReason = 'zod' | 'arg_count' | 'security_error' | 'unknown';
+export interface NetEventInvalidPayloadContext {
+    event: string;
+    reason: NetEventInvalidPayloadReason;
+    playerId: number;
+    accountId?: string;
+    invalidCount: number;
+    zodSummary?: string[];
+    receivedArgsCount?: number;
+    expectedArgsCount?: number;
+}
+export declare abstract class NetEventSecurityObserverContract {
+    abstract onInvalidPayload(player: Player, ctx: NetEventInvalidPayloadContext): Promise<void>;
+}

package/dist/runtime/server/contracts/security/net-event-security-observer.contract.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetEventSecurityObserverContract = void 0;
+class NetEventSecurityObserverContract {
+}
+exports.NetEventSecurityObserverContract = NetEventSecurityObserverContract;

package/dist/{server/templates → runtime/server/contracts}/security/principal-provider.contract.d.ts

@@ -1,6 +1,6 @@
-import type { Server } from '../../..';
-import type { LinkedID } from '../../services';
-import type { Principal } from './permission.types';
+import { Server } from '../../../..';
+import { LinkedID } from '../../services/types/linked-id';
+import { Principal } from './permission.types';
 /**
  * **Authorization**
  *

package/dist/{server/templates → runtime/server/contracts}/security/security-handler.contract.d.ts

@@ -1,5 +1,5 @@
-import type { Server } from '../../..';
-import type { SecurityError } from '../../../utils';
+import { Server } from '../../../..';
+import { SecurityError } from '../../../../kernel/utils/error/security.error';
 export declare abstract class SecurityHandlerContract {
     abstract handleViolation(player: Server.Player, error: SecurityError): Promise<void>;
 }

package/dist/runtime/server/controllers/chat.controller.d.ts

@@ -0,0 +1,11 @@
+import { RGB } from '../../../kernel/utils';
+import { ChatService } from '../services/chat.service';
+import { PlayerDirectoryPort } from '../services/ports/player-directory.port';
+export declare class ChatController {
+    private readonly chatService;
+    private readonly playerDirectory;
+    constructor(chatService: ChatService, playerDirectory: PlayerDirectoryPort);
+    coreBroadcast(message: string, author?: string, color?: RGB): void;
+    coreSendPrivate(targetId: number, message: string, author?: string): void;
+    coreSendToGroupOfPlayers(targets: number[], message: string, author?: string, color?: RGB): void;
+}