@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.2

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

@@ -0,0 +1,195 @@
+export type FrameworkMode = 'CORE' | 'RESOURCE' | 'STANDALONE';
+/**
+ * Feature provider source configuration.
+ *
+ * @remarks
+ * Determines where a feature's implementation comes from:
+ *
+ * - `'core'`: Feature provided by CORE resource via exports
+ *   - Used in RESOURCE mode for: players, principal, auth, commands
+ *   - Triggers remote service implementations that delegate to CORE
+ *
+ * - `'local'`: Feature implemented locally in current resource
+ *   - Used in CORE/STANDALONE for all features
+ *   - Used in RESOURCE for: netEvents, runtimeEvents, exports, http, chat
+ *   - Triggers local service implementations
+ *
+ * @example
+ * ```typescript
+ * // RESOURCE mode - commands delegate to CORE
+ * commands: { enabled: true, provider: 'core' }
+ *
+ * // STANDALONE mode - commands execute locally
+ * commands: { enabled: true, provider: 'local' }
+ * ```
+ */
+export type FeatureProvider = 'core' | 'local';
+export type FeatureScope = 'core' | 'resource' | 'standalone';
+export type FeatureName = 'players' | 'netEvents' | 'runtimeEvents' | 'commands' | 'exports' | 'chat' | 'principal' | 'sessionLifecycle';
+/**
+ * User-facing feature configuration.
+ *
+ * @remarks
+ * Most features are enabled by default and providers are auto-inferred.
+ * Use this config only if you need to explicitly disable a feature.
+ */
+export interface UserFeatureConfig {
+    /** Disable specific features if needed */
+    disabled?: FeatureName[];
+}
+/**
+ * Internal feature contract with all fields resolved.
+ *
+ * @remarks
+ * This is used internally by the framework after merging user config with defaults.
+ * Users don't interact with this directly.
+ *
+ * @internal
+ */
+export interface FeatureContract {
+    /**
+     * Enables or disables the feature at runtime.
+     *
+     * If `required` is `true`, this must also be `true` (otherwise validation will throw).
+     */
+    enabled: boolean;
+    /**
+     * Determines where the implementation comes from.
+     *
+     * - `core`: feature is provided by the core resource (via exports when applicable)
+     * - `local`: feature is implemented/handled locally by the current runtime (resource/standalone)
+     */
+    provider: FeatureProvider;
+    /**
+     * Marks the feature as exportable via FiveM exports.
+     *
+     * Only meaningful in CORE mode. When `true`, the framework dynamically imports
+     * export controllers that expose the feature's API to RESOURCE mode.
+     */
+    export: boolean;
+    /**
+     * The runtime scope this feature contract is intended for.
+     *
+     * Must match the scope derived from the current FrameworkMode
+     */
+    scope: FeatureScope;
+    /**
+     * Marks the feature as mandatory for the current runtime configuration.
+     *
+     * When `true`, the feature cannot be disabled (`enabled` must be `true`).
+     */
+    required: boolean;
+    /**
+     * (sessionLifecycle only) Enable automatic session recovery on resource restart.
+     *
+     * @remarks
+     * When true, scans for connected players on startup and creates sessions
+     * for any that don't have an active session.
+     *
+     * @defaultValue true
+     */
+    recoveryOnRestart?: boolean;
+}
+export type FrameworkFeatures = Record<FeatureName, FeatureContract>;
+export interface DevModeConfig {
+    /**
+     * Master switch for development mode.
+     * If false, no dev tools will be loaded.
+     */
+    enabled: boolean;
+    /**
+     * CLI bridge configuration for telemetry and logs.
+     * The bridge allows the OpenCore CLI to stream logs and inspect the framework state.
+     */
+    bridge?: {
+        /** WebSocket URL of the bridge */
+        url: string;
+        /** Whether to connect automatically on startup */
+        autoConnect: boolean;
+    };
+    /**
+     * Event interceptor configuration for debugging.
+     * Captures and records incoming/outgoing network events and commands.
+     */
+    interceptor?: {
+        /** Enable event interception */
+        enabled: boolean;
+        /** Whether to record a history of events in memory */
+        recordHistory: boolean;
+        /** Maximum number of events to keep in the history buffer */
+        maxHistorySize: number;
+    };
+    /**
+     * Player simulator configuration.
+     * Allows creating virtual players for testing logic without game clients.
+     */
+    simulator?: {
+        /** Enable player simulation features */
+        enabled: boolean;
+        /** Number of virtual players to connect automatically on startup */
+        autoConnectPlayers: number;
+    };
+}
+export interface Hooks {
+    waitFor?: Promise<any> | Promise<any>[];
+    onReady?: () => Promise<void> | void;
+}
+export interface ServerRuntimeOptions {
+    mode: FrameworkMode;
+    features: FrameworkFeatures;
+    coreResourceName: string;
+    adapter?: import('./adapter').OpenCoreServerAdapter;
+    /** Development mode configuration (disabled in production) */
+    devMode?: DevModeConfig;
+    onDependency?: Hooks;
+}
+export type RuntimeContext = ServerRuntimeOptions;
+export declare function setRuntimeContext(ctx: RuntimeContext): void;
+export declare function getRuntimeContext(): RuntimeContext;
+export declare function getFrameworkModeScope(mode: FrameworkMode): FeatureScope;
+/**
+ * Server initialization configuration.
+ *
+ * @remarks
+ * Defines the runtime mode and feature configuration for OpenCore.
+ *
+ * @example Minimal Mode
+ * ```typescript
+ * Server.init({
+ *   mode: 'CORE'
+ * })
+ * ```
+ */
+export interface ServerInitOptions {
+    /** Runtime mode determining feature availability and provider sources */
+    mode: FrameworkMode;
+    /** Optional runtime adapter for non-node server environments. */
+    adapter?: import('./adapter').OpenCoreServerAdapter;
+    /**
+     * Feature configuration.
+     *
+     * @remarks
+     * Most features are enabled by default. Use this only to disable specific ones.
+     */
+    features?: UserFeatureConfig;
+    /**
+     * Name of the CORE resource.
+     *
+     * @remarks
+     * - **Required in RESOURCE mode** (to locate CORE exports)
+     * - Optional in CORE/STANDALONE modes
+     *
+     * @defaultValue 'core'
+     */
+    coreResourceName?: string;
+    /** Development mode configuration (disabled in production) */
+    devMode?: DevModeConfig;
+    /** If you want to wait for a dependency promise, or when ready do something (By default, the core server will emit a "ready" when it is ready to all resources.)  */
+    onDependency?: Hooks;
+}
+export declare function resolveRuntimeOptions(options: ServerInitOptions): ServerRuntimeOptions;
+export declare function validateRuntimeOptions(options: ServerRuntimeOptions): void;
+/**
+ * @deprecated Use validateRuntimeOptions instead
+ */
+export declare const validateRuntimeContextOrThrow: typeof validateRuntimeOptions;

package/dist/runtime/server/runtime.js

@@ -0,0 +1,197 @@
+const FEATURE_NAMES = [
+    'players',
+    'netEvents',
+    'runtimeEvents',
+    'commands',
+    'exports',
+    'chat',
+    'principal',
+    'sessionLifecycle',
+];
+const FEATURE_ALLOWED_SCOPES = {
+    players: ['core', 'resource', 'standalone'],
+    netEvents: ['core', 'resource', 'standalone'],
+    runtimeEvents: ['core', 'resource', 'standalone'],
+    commands: ['core', 'resource', 'standalone'],
+    exports: ['core', 'resource', 'standalone'],
+    chat: ['core', 'resource', 'standalone'],
+    principal: ['core', 'resource', 'standalone'],
+    sessionLifecycle: ['core', 'standalone'],
+};
+let runtimeContext = null;
+export function setRuntimeContext(ctx) {
+    runtimeContext = ctx;
+}
+export function getRuntimeContext() {
+    if (!runtimeContext) {
+        throw new Error('[OpenCore] RuntimeContext is not initialized. Call Server.init({ mode, ... }) before using the framework.');
+    }
+    return runtimeContext;
+}
+export function getFrameworkModeScope(mode) {
+    if (mode === 'CORE')
+        return 'core';
+    if (mode === 'RESOURCE')
+        return 'resource';
+    return 'standalone';
+}
+function createDefaultFeatures(mode) {
+    const scope = getFrameworkModeScope(mode);
+    // Provider logic:
+    // - CORE/STANDALONE: All features use 'local' (run locally)
+    // - RESOURCE: Identity/Command features delegate to CORE ('core'), others run locally ('local')
+    const remoteProvider = mode === 'RESOURCE' ? 'core' : 'local';
+    const isResource = mode === 'RESOURCE';
+    const isCore = mode === 'CORE';
+    return {
+        players: {
+            enabled: true,
+            provider: remoteProvider,
+            export: isCore,
+            scope,
+            required: true,
+        },
+        netEvents: {
+            enabled: true,
+            provider: 'local',
+            export: false,
+            scope,
+            required: true,
+        },
+        runtimeEvents: {
+            enabled: true,
+            provider: 'local',
+            export: false,
+            scope,
+            required: false,
+        },
+        commands: {
+            enabled: true,
+            provider: remoteProvider,
+            export: isCore,
+            scope,
+            required: true,
+        },
+        exports: {
+            enabled: true,
+            provider: 'local',
+            export: false,
+            scope,
+            required: isCore,
+        },
+        chat: {
+            enabled: true,
+            provider: 'local',
+            export: isCore,
+            scope,
+            required: false,
+        },
+        principal: {
+            enabled: true,
+            provider: remoteProvider,
+            export: isCore,
+            scope,
+            required: false,
+        },
+        sessionLifecycle: {
+            enabled: !isResource,
+            provider: 'local',
+            export: false,
+            scope,
+            required: false,
+            recoveryOnRestart: true,
+        },
+    };
+}
+export function resolveRuntimeOptions(options) {
+    const features = createDefaultFeatures(options.mode);
+    if (options.features?.disabled) {
+        for (const name of options.features.disabled) {
+            if (features[name]) {
+                features[name].enabled = false;
+            }
+        }
+    }
+    return {
+        mode: options.mode,
+        features,
+        coreResourceName: options.coreResourceName ?? 'core',
+        adapter: options.adapter,
+        devMode: options.devMode,
+        onDependency: options.onDependency,
+    };
+}
+function assertFeatureKeys(features) {
+    if (!features) {
+        throw new Error('[OpenCore] Runtime options are missing features configuration');
+    }
+    const keys = Object.keys(features);
+    for (const key of keys) {
+        if (!FEATURE_NAMES.includes(key)) {
+            throw new Error(`[OpenCore] Unknown feature: '${key}'`);
+        }
+    }
+}
+export function validateRuntimeOptions(options) {
+    const { mode, features } = options;
+    assertFeatureKeys(features);
+    // If in RESOURCE mode, must have coreResourceName
+    if (mode === 'RESOURCE' && !options.coreResourceName) {
+        throw new Error('[OpenCore] RESOURCE mode requires coreResourceName to be specified');
+    }
+    const scope = getFrameworkModeScope(mode);
+    for (const name of FEATURE_NAMES) {
+        const f = features[name];
+        if (!f.enabled) {
+            if (f.required) {
+                throw new Error(`[OpenCore] Feature '${name}' is required but disabled`);
+            }
+            continue;
+        }
+        const allowedScopes = FEATURE_ALLOWED_SCOPES[name];
+        if (!allowedScopes.includes(scope)) {
+            throw new Error(`[OpenCore] Feature '${name}' is not allowed in scope '${scope}' (allowed: ${allowedScopes.join(', ')})`);
+        }
+        if (f.scope !== scope) {
+            throw new Error(`[OpenCore] Invalid scope for feature '${name}': expected '${scope}' for mode '${mode}', received '${f.scope}'`);
+        }
+        if (f.export && !features.exports.enabled) {
+            throw new Error(`[OpenCore] Feature '${name}' cannot be exported when 'exports' is disabled`);
+        }
+        // Validate provider combinations
+        if (mode === 'CORE' && f.provider === 'core') {
+            throw new Error(`[OpenCore] Feature '${name}' cannot use provider='core' in CORE mode (use 'local' instead)`);
+        }
+        if (mode === 'RESOURCE' && f.provider === 'core' && f.export) {
+            throw new Error(`[OpenCore] Feature '${name}' cannot set export=true when provider='core' in RESOURCE mode`);
+        }
+    }
+    // Feature-specific validations
+    if (features.players.enabled && mode === 'RESOURCE' && features.players.provider !== 'core') {
+        throw new Error(`[OpenCore] Feature 'players' must use provider 'core' in RESOURCE mode`);
+    }
+    if (features.principal.enabled && mode === 'RESOURCE' && features.principal.provider !== 'core') {
+        throw new Error(`[OpenCore] Feature 'principal' must use provider 'core' in RESOURCE mode`);
+    }
+    if (features.commands.enabled && mode === 'RESOURCE' && features.commands.provider !== 'core') {
+        throw new Error(`[OpenCore] Feature 'commands' must use provider 'core' in RESOURCE mode`);
+    }
+    // Commands export validation
+    if (features.commands.export && mode !== 'CORE') {
+        throw new Error(`[OpenCore] Feature 'commands' can only be exported in CORE mode (current mode: '${mode}')`);
+    }
+    // Validate dependencies
+    if (features.commands.enabled && !features.players.enabled) {
+        throw new Error(`[OpenCore] Feature 'commands' requires 'players' to be enabled`);
+    }
+    if (features.netEvents.enabled && !features.players.enabled) {
+        throw new Error(`[OpenCore] Feature 'netEvents' requires 'players' to be enabled`);
+    }
+    if (features.chat.enabled && !features.players.enabled) {
+        throw new Error(`[OpenCore] Feature 'chat' requires 'players' to be enabled`);
+    }
+}
+/**
+ * @deprecated Use validateRuntimeOptions instead
+ */
+export const validateRuntimeContextOrThrow = validateRuntimeOptions;

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

@@ -0,0 +1,7 @@
+import * as BaseServerApi from './api';
+import type { ServerPluginApi } from './library/plugin/server-plugin-api';
+export type ServerApi = typeof BaseServerApi & ServerPluginApi & {
+    registerApiExtension(key: string, value: unknown): void;
+};
+export declare function createServerRuntime(): ServerApi;
+export declare const Server: ServerApi;

package/dist/runtime/server/server.runtime.js

@@ -0,0 +1,34 @@
+import * as BaseServerApi from './api';
+const RESERVED_SERVER_API_KEYS = new Set([
+    'registerApiExtension',
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+function assertExtensionKey(key) {
+    if (!key || key.trim().length === 0) {
+        throw new Error('Server API extension key must be a non-empty string');
+    }
+    if (RESERVED_SERVER_API_KEYS.has(key)) {
+        throw new Error(`Server API extension key "${key}" is reserved`);
+    }
+}
+function attachApiExtensionRuntime(runtime) {
+    const dynamicApi = {};
+    runtime.registerApiExtension = (key, value) => {
+        assertExtensionKey(key);
+        if (Object.hasOwn(dynamicApi, key) || key in runtime) {
+            throw new Error(`Server API "${key}" already registered`);
+        }
+        dynamicApi[key] = value;
+        runtime[key] = value;
+    };
+    return runtime;
+}
+export function createServerRuntime() {
+    const runtime = {
+        ...BaseServerApi,
+    };
+    return attachApiExtensionRuntime(runtime);
+}
+export const Server = attachApiExtensionRuntime(BaseServerApi);

package/dist/runtime/server/services/appearance.service.d.ts

@@ -0,0 +1,4 @@
+import { AppearanceValidationResult, PlayerAppearance } from '../../../kernel/shared';
+export declare class AppearanceService {
+    validateAppearance(appearance: Partial<PlayerAppearance>): AppearanceValidationResult;
+}

package/dist/runtime/server/services/appearance.service.js

@@ -0,0 +1,130 @@
+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';
+let AppearanceService = class AppearanceService {
+    validateAppearance(appearance) {
+        const errors = [];
+        if (!appearance) {
+            return { valid: false, errors: ['Appearance data is null or undefined'] };
+        }
+        if (appearance.components) {
+            for (const [id, data] of Object.entries(appearance.components)) {
+                const componentId = parseInt(id, 10);
+                if (Number.isNaN(componentId) || componentId < 0 || componentId > 11) {
+                    errors.push(`Invalid component ID: ${id} (must be 0-11)`);
+                }
+                if (data.drawable === undefined || data.drawable < -1) {
+                    errors.push(`Invalid drawable for component ${id}`);
+                }
+                if (data.texture === undefined || data.texture < 0) {
+                    errors.push(`Invalid texture for component ${id}`);
+                }
+            }
+        }
+        if (appearance.props) {
+            for (const [id, data] of Object.entries(appearance.props)) {
+                const propId = parseInt(id, 10);
+                if (Number.isNaN(propId) || propId < 0 || propId > 7) {
+                    errors.push(`Invalid prop ID: ${id} (must be 0-7)`);
+                }
+                if (data.drawable === undefined) {
+                    errors.push(`Missing drawable for prop ${id}`);
+                }
+                if (data.texture === undefined || data.texture < 0) {
+                    errors.push(`Invalid texture for prop ${id}`);
+                }
+            }
+        }
+        if (appearance.faceFeatures) {
+            for (const [id, value] of Object.entries(appearance.faceFeatures)) {
+                const index = parseInt(id, 10);
+                if (Number.isNaN(index) || index < 0 || index > 19) {
+                    errors.push(`Invalid face feature index: ${id} (must be 0-19)`);
+                }
+                if (typeof value !== 'number' || value < -1.0 || value > 1.0) {
+                    errors.push(`Face feature ${id} value out of range: ${value} (must be -1.0 to 1.0)`);
+                }
+            }
+        }
+        if (appearance.headBlend) {
+            const hb = appearance.headBlend;
+            if (typeof hb.shapeFirst !== 'number' || hb.shapeFirst < 0 || hb.shapeFirst > 45)
+                errors.push('Invalid shapeFirst (must be 0-45)');
+            if (typeof hb.shapeSecond !== 'number' || hb.shapeSecond < 0 || hb.shapeSecond > 45)
+                errors.push('Invalid shapeSecond (must be 0-45)');
+            if (typeof hb.skinFirst !== 'number' || hb.skinFirst < 0 || hb.skinFirst > 45)
+                errors.push('Invalid skinFirst (must be 0-45)');
+            if (typeof hb.skinSecond !== 'number' || hb.skinSecond < 0 || hb.skinSecond > 45)
+                errors.push('Invalid skinSecond (must be 0-45)');
+            if (typeof hb.shapeMix !== 'number' || hb.shapeMix < 0 || hb.shapeMix > 1)
+                errors.push('Invalid shapeMix (must be 0.0-1.0)');
+            if (typeof hb.skinMix !== 'number' || hb.skinMix < 0 || hb.skinMix > 1)
+                errors.push('Invalid skinMix (must be 0.0-1.0)');
+            if (hb.shapeThird !== undefined && (hb.shapeThird < 0 || hb.shapeThird > 45))
+                errors.push('Invalid shapeThird (must be 0-45)');
+            if (hb.skinThird !== undefined && (hb.skinThird < 0 || hb.skinThird > 45))
+                errors.push('Invalid skinThird (must be 0-45)');
+            if (hb.thirdMix !== undefined && (hb.thirdMix < 0 || hb.thirdMix > 1))
+                errors.push('Invalid thirdMix (must be 0.0-1.0)');
+        }
+        if (appearance.headOverlays) {
+            for (const [id, overlay] of Object.entries(appearance.headOverlays)) {
+                const overlayId = parseInt(id, 10);
+                if (Number.isNaN(overlayId) || overlayId < 0 || overlayId > 12) {
+                    errors.push(`Invalid overlay ID: ${id} (must be 0-12)`);
+                }
+                if (typeof overlay.index !== 'number' || overlay.index < 0)
+                    errors.push(`Invalid overlay index for ID ${id}`);
+                if (typeof overlay.opacity !== 'number' || overlay.opacity < 0 || overlay.opacity > 1) {
+                    errors.push(`Invalid overlay opacity for ID ${id} (must be 0.0-1.0)`);
+                }
+                if (overlay.colorType !== undefined && ![0, 1, 2].includes(overlay.colorType)) {
+                    errors.push(`Invalid overlay colorType for ID ${id} (must be 0, 1, or 2)`);
+                }
+            }
+        }
+        if (appearance.hairColor) {
+            if (typeof appearance.hairColor.colorId !== 'number' || appearance.hairColor.colorId < 0)
+                errors.push('Invalid hair colorId');
+            if (typeof appearance.hairColor.highlightColorId !== 'number' ||
+                appearance.hairColor.highlightColorId < 0) {
+                errors.push('Invalid hair highlightColorId');
+            }
+        }
+        if (appearance.eyeColor !== undefined) {
+            if (typeof appearance.eyeColor !== 'number' ||
+                appearance.eyeColor < 0 ||
+                appearance.eyeColor > 31) {
+                errors.push(`Invalid eye color: ${appearance.eyeColor} (must be 0-31)`);
+            }
+        }
+        if (appearance.tattoos) {
+            if (!Array.isArray(appearance.tattoos)) {
+                errors.push('Tattoos must be an array');
+            }
+            else {
+                for (let i = 0; i < appearance.tattoos.length; i++) {
+                    const tattoo = appearance.tattoos[i];
+                    if (!tattoo.collection || typeof tattoo.collection !== 'string')
+                        errors.push(`Invalid tattoo collection at index ${i}`);
+                    if (!tattoo.overlay || typeof tattoo.overlay !== 'string')
+                        errors.push(`Invalid tattoo overlay at index ${i}`);
+                }
+            }
+        }
+        if (appearance.model !== undefined) {
+            if (typeof appearance.model !== 'string' || appearance.model.length === 0) {
+                errors.push('Invalid model (must be a non-empty string)');
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+};
+AppearanceService = __decorate([
+    injectable()
+], AppearanceService);
+export { AppearanceService };

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

@@ -0,0 +1,6 @@
+export * from './appearance.service';
+export { SessionRecoveryService } from './session-recovery.local';
+export { PlayerPersistenceService } from './persistence.service';
+export * from '../ports/internal/command-execution.port';
+export type * from '../types/linked-id';
+export * from '../types/player-session.types';

package/dist/runtime/server/services/index.js

@@ -0,0 +1,6 @@
+// Services
+export * from './appearance.service';
+export { SessionRecoveryService } from './session-recovery.local';
+export { PlayerPersistenceService } from './persistence.service';
+export * from '../ports/internal/command-execution.port';
+export * from '../types/player-session.types';

package/dist/runtime/server/services/parallel/native-worker.entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/services/parallel/native-worker.entry.js

@@ -0,0 +1,10 @@
+import { parentPort } from 'node:worker_threads';
+import { processMessage } from './worker';
+const port = parentPort;
+if (!port) {
+    throw new Error('native-worker.entry.ts must be executed inside a Worker thread');
+}
+port.on('message', (message) => {
+    const response = processMessage(message);
+    port.postMessage(response);
+});

package/dist/runtime/server/services/parallel/worker-pool.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Worker Pool
+ *
+ * Native worker thread pool for CPU-bound computations.
+ * Tasks are executed in `node:worker_threads` and communicated through
+ * structured-cloned messages.
+ */
+import { WorkerInfo, WorkerMessage, WorkerPoolConfig } from '../../types/parallel.types';
+type EventCallback = (...args: unknown[]) => void;
+/**
+ * Simple event emitter (FiveM compatible)
+ */
+declare class SimpleEventEmitter {
+    private events;
+    on(event: string, callback: EventCallback): void;
+    off(event: string, callback: EventCallback): void;
+    emit(event: string, ...args: unknown[]): void;
+}
+export declare class WorkerPool extends SimpleEventEmitter {
+    private workers;
+    private taskQueue;
+    private config;
+    private workerIdCounter;
+    private cleanupInterval;
+    private isShuttingDown;
+    private workerScriptPath;
+    constructor(config?: Partial<WorkerPoolConfig>);
+    /**
+     * Check if using native workers
+     */
+    get isNative(): boolean;
+    /**
+     * Execute a task
+     */
+    execute(message: WorkerMessage): Promise<unknown>;
+    /**
+     * Get current pool statistics
+     */
+    getStats(): {
+        totalWorkers: number;
+        idleWorkers: number;
+        busyWorkers: number;
+        queuedTasks: number;
+        isNative: boolean;
+    };
+    /**
+     * Get all worker info
+     */
+    getWorkerInfo(): WorkerInfo[];
+    /**
+     * Shutdown the pool gracefully
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Spawn a new native worker
+     */
+    private spawnWorker;
+    /**
+     * Find an idle worker
+     */
+    private findIdleWorker;
+    /**
+     * Assign a task to a worker
+     */
+    private assignTask;
+    /**
+     * Handle task timeout
+     */
+    private handleTaskTimeout;
+    /**
+     * Process queued tasks
+     */
+    private processQueue;
+    /**
+     * Cleanup idle workers
+     */
+    private cleanupIdleWorkers;
+}
+export {};