@open-core/framework 0.1.0-alpha.1

package/dist/server/services/config.service.js

@@ -0,0 +1,116 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const decorators_1 = require("../decorators");
+/**
+ * Generic configuration service for accessing FiveM Convars.
+ *
+ * Provides type-safe access to configuration values with automatic
+ * prefix handling and type conversion.
+ *
+ * All keys are automatically prefixed with `opencore_`.
+ *
+ * @example
+ * ```ts
+ * const config = di.resolve(ConfigService)
+ *
+ * // Get string value
+ * const apiUrl = config.get('api_url', 'http://localhost:3000')
+ *
+ * // Get number value
+ * const timeout = config.getNumber('timeout', 5000)
+ *
+ * // Get boolean value
+ * const debug = config.getBoolean('debug', false)
+ *
+ * // Get required value (throws if not set)
+ * const secretKey = config.getRequired('secret_key')
+ *
+ * // Get JSON value
+ * const settings = config.getJson('settings', { enabled: true })
+ * ```
+ *
+ * @scope Singleton
+ */
+let ConfigService = class ConfigService {
+    constructor() {
+        this.PREFIX = 'opencore_';
+    }
+    /**
+     * Gets a string configuration value.
+     *
+     * @param key - The configuration key (without prefix)
+     * @param defaultValue - Default value if not set
+     * @returns The configuration value or default
+     */
+    get(key, defaultValue) {
+        return GetConvar(this.PREFIX + key, defaultValue);
+    }
+    /**
+     * Gets a numeric configuration value.
+     *
+     * @param key - The configuration key (without prefix)
+     * @param defaultValue - Default value if not set or invalid
+     * @returns The configuration value as number
+     */
+    getNumber(key, defaultValue) {
+        const value = GetConvar(this.PREFIX + key, String(defaultValue));
+        const parsed = Number(value);
+        return isNaN(parsed) ? defaultValue : parsed;
+    }
+    /**
+     * Gets a boolean configuration value.
+     *
+     * Recognizes 'true', '1' as true, everything else as false.
+     *
+     * @param key - The configuration key (without prefix)
+     * @param defaultValue - Default value if not set
+     * @returns The configuration value as boolean
+     */
+    getBoolean(key, defaultValue) {
+        const value = GetConvar(this.PREFIX + key, String(defaultValue));
+        return value === 'true' || value === '1';
+    }
+    /**
+     * Gets a required configuration value.
+     *
+     * @param key - The configuration key (without prefix)
+     * @returns The configuration value
+     * @throws Error if the value is not set
+     */
+    getRequired(key) {
+        const value = GetConvar(this.PREFIX + key, '');
+        if (!value) {
+            throw new Error(`[OpenCore] Configuration '${this.PREFIX}${key}' is required but not set`);
+        }
+        return value;
+    }
+    /**
+     * Gets a JSON configuration value.
+     *
+     * @param key - The configuration key (without prefix)
+     * @param defaultValue - Default value if not set or invalid JSON
+     * @returns The parsed JSON value or default
+     */
+    getJson(key, defaultValue) {
+        const value = GetConvar(this.PREFIX + key, '');
+        if (!value)
+            return defaultValue;
+        try {
+            return JSON.parse(value);
+        }
+        catch (_a) {
+            return defaultValue;
+        }
+    }
+};
+exports.ConfigService = ConfigService;
+exports.ConfigService = ConfigService = __decorate([
+    (0, decorators_1.Bind)('singleton')
+], ConfigService);

package/dist/server/services/default/default-security.handler.d.ts

@@ -0,0 +1,6 @@
+import { SecurityHandlerContract } from '../../templates/security/security-handler.contract';
+import { Server } from '../../..';
+import { SecurityError } from '../../../utils/errors';
+export declare class DefaultSecurityHandler extends SecurityHandlerContract {
+    handleViolation(player: Server.Player, error: SecurityError): Promise<void>;
+}

package/dist/server/services/default/default-security.handler.js

@@ -0,0 +1,26 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSecurityHandler = void 0;
+const tsyringe_1 = require("tsyringe");
+const security_handler_contract_1 = require("../../templates/security/security-handler.contract");
+const logger_1 = require("../../../shared/logger");
+let DefaultSecurityHandler = class DefaultSecurityHandler extends security_handler_contract_1.SecurityHandlerContract {
+    async handleViolation(player, error) {
+        logger_1.loggers.security.warn(`Security violation detected`, {
+            playerName: player.name,
+            playerId: player.clientID,
+            message: error.message,
+            suggestedAction: error.action,
+        });
+    }
+};
+exports.DefaultSecurityHandler = DefaultSecurityHandler;
+exports.DefaultSecurityHandler = DefaultSecurityHandler = __decorate([
+    (0, tsyringe_1.injectable)()
+], DefaultSecurityHandler);

package/dist/server/services/http/http.service.d.ts

@@ -0,0 +1,50 @@
+export interface HttpOptions {
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+export declare class HttpService {
+    /**
+     * Performs an HTTP GET request to the specified URL.
+     *
+     * @template T - The expected return type of the response data.
+     * @param url - The endpoint URL to fetch data from.
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    get<T = any>(url: string, options?: HttpOptions): Promise<T>;
+    /**
+     * Performs an HTTP POST request to the specified URL with a JSON payload.
+     *
+     * @template T - The expected return type of the response data.
+     * @param url - The endpoint URL to send data to.
+     * @param body - The data payload to be sent as the request body (will be stringified to JSON).
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    post<T = any>(url: string, body: any, options?: HttpOptions): Promise<T>;
+    /**
+     * Performs an HTTP PUT request to the specified URL to update a resource.
+     *
+     * @template T - The expected return type of the response data.
+     * @param url - The endpoint URL to update.
+     * @param body - The data payload to be sent as the request body (will be stringified to JSON).
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    put<T = any>(url: string, body: any, options?: HttpOptions): Promise<T>;
+    /**
+     * Performs an HTTP DELETE request to the specified URL.
+     *
+     * @template T - The expected return type of the response data (often void or the deleted entity).
+     * @param url - The endpoint URL to delete the resource from.
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    delete<T = any>(url: string, options?: HttpOptions): Promise<T>;
+    private request;
+    private handleResponse;
+}

package/dist/server/services/http/http.service.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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpService = void 0;
+const tsyringe_1 = require("tsyringe");
+const utils_1 = require("../../../utils");
+let HttpService = class HttpService {
+    /**
+     * Performs an HTTP GET request to the specified URL.
+     *
+     * @template T - The expected return type of the response data.
+     * @param url - The endpoint URL to fetch data from.
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    async get(url, options = {}) {
+        return this.request(url, 'GET', undefined, options);
+    }
+    /**
+     * Performs an HTTP POST request to the specified URL with a JSON payload.
+     *
+     * @template T - The expected return type of the response data.
+     * @param url - The endpoint URL to send data to.
+     * @param body - The data payload to be sent as the request body (will be stringified to JSON).
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    async post(url, body, options = {}) {
+        return this.request(url, 'POST', body, options);
+    }
+    /**
+     * Performs an HTTP PUT request to the specified URL to update a resource.
+     *
+     * @template T - The expected return type of the response data.
+     * @param url - The endpoint URL to update.
+     * @param body - The data payload to be sent as the request body (will be stringified to JSON).
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    async put(url, body, options = {}) {
+        return this.request(url, 'PUT', body, options);
+    }
+    /**
+     * Performs an HTTP DELETE request to the specified URL.
+     *
+     * @template T - The expected return type of the response data (often void or the deleted entity).
+     * @param url - The endpoint URL to delete the resource from.
+     * @param options - Optional configuration for the request (headers, timeout).
+     * @returns A Promise that resolves to the response data of type T.
+     * @throws {AppError} If the request fails, times out, or returns a non-2xx status code.
+     */
+    async delete(url, options = {}) {
+        return this.request(url, 'DELETE', undefined, options);
+    }
+    async request(url, method, body, options) {
+        const { headers = {}, timeoutMs = 5000 } = options;
+        const finalHeaders = Object.assign({ 'Content-Type': 'application/json' }, headers);
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: finalHeaders,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            return await this.handleResponse(response, method, url);
+        }
+        catch (err) {
+            if (err instanceof utils_1.AppError)
+                throw err;
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                throw new utils_1.AppError('NETWORK_ERROR', `${method} ${url} timed out after ${timeoutMs}ms`, 'external', { timeout: timeoutMs });
+            }
+            throw new utils_1.AppError('NETWORK_ERROR', `Network error calling ${method} ${url}`, 'external', {
+                endpoint: url,
+                method,
+                cause: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            clearTimeout(id);
+        }
+    }
+    async handleResponse(response, method, url) {
+        if (!response.ok) {
+            let code = 'API_ERROR';
+            let errorBody = null;
+            if (response.status === 401 || response.status === 403) {
+                code = 'UNAUTHORIZED';
+            }
+            try {
+                errorBody = await response.json();
+            }
+            catch (_) { }
+            throw new utils_1.AppError(code, `${method} ${url} failed with status ${response.status}`, 'external', {
+                status: response.status,
+                endpoint: url,
+                method,
+                body: errorBody,
+            });
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        try {
+            return (await response.json());
+        }
+        catch (_) {
+            // TODO: define better behavior for non-JSON responses
+            return undefined;
+        }
+    }
+};
+exports.HttpService = HttpService;
+exports.HttpService = HttpService = __decorate([
+    (0, tsyringe_1.injectable)()
+], HttpService);

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

@@ -0,0 +1,10 @@
+export * from './player.service';
+export * from './command.service';
+export * from './http/http.service';
+export * from './access-control.service';
+export * from './chat.service';
+export * from './rate-limiter.service';
+export * from './persistence.service';
+export * from './parallel';
+export * from './config.service';
+export * from '../database';

package/dist/server/services/index.js

@@ -0,0 +1,26 @@
+"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 __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 });
+__exportStar(require("./player.service"), exports);
+__exportStar(require("./command.service"), exports);
+__exportStar(require("./http/http.service"), exports);
+__exportStar(require("./access-control.service"), exports);
+__exportStar(require("./chat.service"), exports);
+__exportStar(require("./rate-limiter.service"), exports);
+__exportStar(require("./persistence.service"), exports);
+__exportStar(require("./parallel"), exports);
+__exportStar(require("./config.service"), exports);
+__exportStar(require("../database"), exports);

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

@@ -0,0 +1,49 @@
+/**
+ * ParallelCompute Module
+ *
+ * Provides parallel computation capabilities using worker threads.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   initParallelCompute,
+ *   defineTask,
+ *   filterByDistance,
+ * } from '@open-core/framework/server'
+ *
+ * // Initialize the worker pool (call once at startup)
+ * initParallelCompute({ maxWorkers: 4 })
+ *
+ * // Use built-in tasks
+ * const nearby = await filterByDistance.run({
+ *   entities: allEntities,
+ *   position: player.coords,
+ *   radius: 100,
+ * })
+ *
+ * // Define custom tasks
+ * const processPlayers = defineTask({
+ *   name: 'processPlayers',
+ *   estimateCost: (input) => input.length * 10,
+ *   workerThreshold: 500,
+ *   compute: (players) => players.map(p => ({
+ *     ...p,
+ *     processed: true,
+ *   })),
+ * })
+ *
+ * // Run with automatic mode selection
+ * const result = await processPlayers.run(players)
+ *
+ * // Force sync execution
+ * const resultSync = processPlayers.sync(players)
+ *
+ * // Force parallel execution
+ * const resultParallel = await processPlayers.parallel(players)
+ * ```
+ */
+export type { ExecutionMode, WorkerPoolConfig, ParallelTaskOptions, ParallelTask, ParallelComputeMetrics, TaskResult, WorkerInfo, WorkerStatus, } from './types';
+export { ParallelComputeService } from './parallel-compute.service';
+export { getParallelComputeService, initParallelCompute, shutdownParallelCompute, defineTask, } from './parallel-compute.service';
+export { filterByDistance, sortByDistance, findClosest, defineBatchTransform, defineBatchFilter, defineBatchReduce, type Vector3Like, } from './parallel-compute.service';
+export { WorkerPool } from './worker-pool';

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

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * ParallelCompute Module
+ *
+ * Provides parallel computation capabilities using worker threads.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   initParallelCompute,
+ *   defineTask,
+ *   filterByDistance,
+ * } from '@open-core/framework/server'
+ *
+ * // Initialize the worker pool (call once at startup)
+ * initParallelCompute({ maxWorkers: 4 })
+ *
+ * // Use built-in tasks
+ * const nearby = await filterByDistance.run({
+ *   entities: allEntities,
+ *   position: player.coords,
+ *   radius: 100,
+ * })
+ *
+ * // Define custom tasks
+ * const processPlayers = defineTask({
+ *   name: 'processPlayers',
+ *   estimateCost: (input) => input.length * 10,
+ *   workerThreshold: 500,
+ *   compute: (players) => players.map(p => ({
+ *     ...p,
+ *     processed: true,
+ *   })),
+ * })
+ *
+ * // Run with automatic mode selection
+ * const result = await processPlayers.run(players)
+ *
+ * // Force sync execution
+ * const resultSync = processPlayers.sync(players)
+ *
+ * // Force parallel execution
+ * const resultParallel = await processPlayers.parallel(players)
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = exports.defineBatchReduce = exports.defineBatchFilter = exports.defineBatchTransform = exports.findClosest = exports.sortByDistance = exports.filterByDistance = exports.defineTask = exports.shutdownParallelCompute = exports.initParallelCompute = exports.getParallelComputeService = exports.ParallelComputeService = void 0;
+// Service
+var parallel_compute_service_1 = require("./parallel-compute.service");
+Object.defineProperty(exports, "ParallelComputeService", { enumerable: true, get: function () { return parallel_compute_service_1.ParallelComputeService; } });
+// Standalone functions
+var parallel_compute_service_2 = require("./parallel-compute.service");
+Object.defineProperty(exports, "getParallelComputeService", { enumerable: true, get: function () { return parallel_compute_service_2.getParallelComputeService; } });
+Object.defineProperty(exports, "initParallelCompute", { enumerable: true, get: function () { return parallel_compute_service_2.initParallelCompute; } });
+Object.defineProperty(exports, "shutdownParallelCompute", { enumerable: true, get: function () { return parallel_compute_service_2.shutdownParallelCompute; } });
+Object.defineProperty(exports, "defineTask", { enumerable: true, get: function () { return parallel_compute_service_2.defineTask; } });
+// Built-in tasks
+var parallel_compute_service_3 = require("./parallel-compute.service");
+Object.defineProperty(exports, "filterByDistance", { enumerable: true, get: function () { return parallel_compute_service_3.filterByDistance; } });
+Object.defineProperty(exports, "sortByDistance", { enumerable: true, get: function () { return parallel_compute_service_3.sortByDistance; } });
+Object.defineProperty(exports, "findClosest", { enumerable: true, get: function () { return parallel_compute_service_3.findClosest; } });
+Object.defineProperty(exports, "defineBatchTransform", { enumerable: true, get: function () { return parallel_compute_service_3.defineBatchTransform; } });
+Object.defineProperty(exports, "defineBatchFilter", { enumerable: true, get: function () { return parallel_compute_service_3.defineBatchFilter; } });
+Object.defineProperty(exports, "defineBatchReduce", { enumerable: true, get: function () { return parallel_compute_service_3.defineBatchReduce; } });
+// Worker pool (for advanced usage)
+var worker_pool_1 = require("./worker-pool");
+Object.defineProperty(exports, "WorkerPool", { enumerable: true, get: function () { return worker_pool_1.WorkerPool; } });

package/dist/server/services/parallel/parallel-compute.service.d.ts

@@ -0,0 +1,132 @@
+/**
+ * ParallelCompute Service
+ *
+ * Provides an ergonomic API for parallel computation.
+ * Uses virtual workers in FiveM environment, with async execution
+ * that yields to the event loop for better performance.
+ *
+ * Automatically decides whether to run synchronously or asynchronously
+ * based on estimated computational cost.
+ */
+import type { ParallelTaskOptions, ParallelTask, WorkerPoolConfig, ParallelComputeMetrics, TaskResult } from './types';
+/**
+ * Service for managing parallel computation
+ */
+export declare class ParallelComputeService {
+    private pool;
+    private metrics;
+    private totalExecutionTime;
+    private isInitialized;
+    private poolConfig;
+    /**
+     * Initialize the worker pool
+     * Must be called before using parallel execution
+     */
+    initialize(config?: Partial<WorkerPoolConfig>): void;
+    /**
+     * Check if initialized
+     */
+    get initialized(): boolean;
+    /**
+     * Check if using native workers
+     */
+    get isNative(): boolean;
+    /**
+     * Shutdown the service and worker pool
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): ParallelComputeMetrics;
+    /**
+     * Get worker pool statistics
+     */
+    getPoolStats(): {
+        totalWorkers: number;
+        idleWorkers: number;
+        busyWorkers: number;
+        queuedTasks: number;
+        isNative: boolean;
+    } | null;
+    /**
+     * Reset metrics
+     */
+    resetMetrics(): void;
+    /**
+     * Execute a compute function with automatic mode selection
+     */
+    run<TInput, TOutput>(options: ParallelTaskOptions<TInput, TOutput>, input: TInput): Promise<TaskResult<TOutput>>;
+    /**
+     * Execute synchronously on main thread
+     */
+    sync<TInput, TOutput>(options: ParallelTaskOptions<TInput, TOutput>, input: TInput): TaskResult<TOutput>;
+    /**
+     * Execute on worker (async with yielding in FiveM)
+     */
+    parallel<TInput, TOutput>(options: ParallelTaskOptions<TInput, TOutput>, input: TInput): Promise<TaskResult<TOutput>>;
+    /**
+     * Execute distributed across multiple workers
+     */
+    distributed<TInput, TOutput>(options: ParallelTaskOptions<TInput, TOutput>, input: TInput, workerCount?: number): Promise<TaskResult<TOutput>>;
+    /**
+     * Update internal metrics
+     */
+    private updateMetrics;
+}
+/**
+ * Get or create the global ParallelCompute service instance
+ */
+export declare function getParallelComputeService(): ParallelComputeService;
+/**
+ * Initialize the global ParallelCompute service
+ */
+export declare function initParallelCompute(config?: Partial<WorkerPoolConfig>): void;
+/**
+ * Shutdown the global ParallelCompute service
+ */
+export declare function shutdownParallelCompute(): Promise<void>;
+/**
+ * Define a parallel task with the given options
+ * Returns a task object with run, sync, parallel, and distributed methods
+ */
+export declare function defineTask<TInput, TOutput>(options: ParallelTaskOptions<TInput, TOutput>): ParallelTask<TInput, TOutput>;
+export interface Vector3Like {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Built-in task: Filter entities by distance from a position
+ */
+export declare const filterByDistance: ParallelTask<{
+    entities: Vector3Like[];
+    position: Vector3Like;
+    radius: number;
+}, Vector3Like[]>;
+/**
+ * Built-in task: Sort entities by distance from a position
+ */
+export declare const sortByDistance: ParallelTask<{
+    entities: Vector3Like[];
+    position: Vector3Like;
+}, Vector3Like[]>;
+/**
+ * Built-in task: Find closest entity to a position
+ */
+export declare const findClosest: ParallelTask<{
+    entities: Vector3Like[];
+    position: Vector3Like;
+}, Vector3Like | null>;
+/**
+ * Built-in task: Batch transform items
+ */
+export declare function defineBatchTransform<T, R>(name: string, transform: (item: T) => R, threshold?: number): ParallelTask<T[], R[]>;
+/**
+ * Built-in task: Batch filter items
+ */
+export declare function defineBatchFilter<T>(name: string, predicate: (item: T) => boolean, threshold?: number): ParallelTask<T[], T[]>;
+/**
+ * Built-in task: Batch reduce items
+ */
+export declare function defineBatchReduce<T, R>(name: string, reducer: (acc: R, item: T) => R, initial: R, merger: (results: R[]) => R, threshold?: number): ParallelTask<T[], R>;