@juspay/neurolink 9.40.0 → 9.42.0

package/dist/services/server/ai/observability/instrumentation.d.ts

@@ -8,7 +8,8 @@
  */
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { trace } from "@opentelemetry/api";
-import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import type { LangfuseConfig } from "../../../../types/observability.js";
 /**
@@ -104,6 +105,11 @@ export declare function getLangfuseSpanProcessor(): LangfuseSpanProcessor | null
  * Get the tracer provider
  */
 export declare function getTracerProvider(): NodeTracerProvider | null;
+/**
+ * Get the logger provider for emitting OTLP log records.
+ * Returns null if OTLP is not configured or LoggerProvider was not created.
+ */
+export declare function getLoggerProvider(): LoggerProvider | null;
 /**
  * Check if OpenTelemetry is initialized
  */

package/dist/services/server/ai/observability/instrumentation.js

@@ -7,8 +7,15 @@
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
 import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { trace } from "@opentelemetry/api";
+import { metrics, trace } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "async_hooks";
@@ -16,6 +23,8 @@ import { logger } from "../../../../utils/logger.js";
 const LOG_PREFIX = "[OpenTelemetry]";
 const contextStorage = new AsyncLocalStorage();
 let tracerProvider = null;
+let meterProvider = null;
+let loggerProvider = null;
 let langfuseProcessor = null;
 let isInitialized = false;
 let isCredentialsValid = false;
@@ -453,58 +462,179 @@ export function initializeOpenTelemetry(config) {
             return;
         }
     }
-    // THEN: Check enabled for standalone mode
-    if (!config?.enabled) {
-        logger.debug(`${LOG_PREFIX} Langfuse disabled and no external provider, skipping initialization`);
+    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const langfuseRequested = config?.enabled === true;
+    const hasLangfuseCreds = !!config.publicKey && !!config.secretKey;
+    // THEN: Check whether we have any standalone observability backend at all.
+    if ((!langfuseRequested || !hasLangfuseCreds) && !otlpEndpoint) {
+        if (langfuseRequested && !hasLangfuseCreds) {
+            logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing, and no OTLP endpoint is configured; skipping initialization`, {
+                hasPublicKey: !!config.publicKey,
+                hasSecretKey: !!config.secretKey,
+            });
+        }
+        else {
+            logger.debug(`${LOG_PREFIX} Langfuse disabled and OTLP endpoint missing, skipping initialization`);
+        }
         isInitialized = true;
         return;
     }
-    // Validate credentials for standalone mode
-    if (!config.publicKey || !config.secretKey) {
-        logger.warn(`${LOG_PREFIX} Langfuse enabled but missing credentials, skipping initialization`, {
+    if (langfuseRequested && !hasLangfuseCreds) {
+        logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing; continuing with OTLP-only telemetry`, {
             hasPublicKey: !!config.publicKey,
             hasSecretKey: !!config.secretKey,
+            otlpEnabled: !!otlpEndpoint,
         });
-        isInitialized = true;
-        isCredentialsValid = false;
-        return;
     }
     try {
         currentConfig = config;
-        isCredentialsValid = true;
-        // Step 1: Create LangfuseSpanProcessor for standalone mode
-        // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
-        langfuseProcessor = new LangfuseSpanProcessor({
-            publicKey: config.publicKey,
-            secretKey: config.secretKey,
-            baseUrl: config.baseUrl || "https://cloud.langfuse.com",
-            environment: config.environment || "dev",
-            release: config.release || "v1.0.0",
-            shouldExportSpan: () => true,
-        });
-        logger.debug(`${LOG_PREFIX} Created LangfuseSpanProcessor`, {
+        isCredentialsValid = hasLangfuseCreds;
+        // Step 1: Create LangfuseSpanProcessor only when Langfuse is explicitly enabled
+        // with real credentials. OTLP-only mode is valid and should not construct one.
+        if (langfuseRequested && hasLangfuseCreds) {
+            // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
+            langfuseProcessor = new LangfuseSpanProcessor({
+                publicKey: config.publicKey,
+                secretKey: config.secretKey,
+                baseUrl: config.baseUrl || "https://cloud.langfuse.com",
+                environment: config.environment || "dev",
+                release: config.release || "v1.0.0",
+                shouldExportSpan: () => true,
+            });
+        }
+        else {
+            langfuseProcessor = null;
+        }
+        logger.debug(`${LOG_PREFIX} Standalone observability mode`, {
+            langfuseEnabled: !!langfuseProcessor,
+            otlpEnabled: !!otlpEndpoint,
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
         });
         // Step 2: Create our own TracerProvider (standalone behavior)
+        // Use OTEL_SERVICE_NAME env var if available, otherwise "neurolink"
+        const serviceName = process.env.OTEL_SERVICE_NAME || "neurolink";
         const resource = resourceFromAttributes({
-            [ATTR_SERVICE_NAME]: "neurolink",
+            [ATTR_SERVICE_NAME]: serviceName,
             [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
             "deployment.environment": config.environment || "dev",
         });
+        // Build span processor list
+        const spanProcessors = [new ContextEnricher()];
+        if (langfuseProcessor) {
+            spanProcessors.push(langfuseProcessor);
+        }
+        // Step 2b: If OTEL_EXPORTER_OTLP_ENDPOINT is set, also export via OTLP HTTP
+        // This allows sending traces to an OpenTelemetry Collector (e.g. for OpenObserve)
+        if (otlpEndpoint) {
+            try {
+                const otlpExporter = new OTLPTraceExporter({
+                    url: `${otlpEndpoint}/v1/traces`,
+                });
+                const otlpBatchProcessor = new BatchSpanProcessor(otlpExporter, {
+                    maxQueueSize: 2048,
+                    maxExportBatchSize: 512,
+                    scheduledDelayMillis: 1000,
+                    exportTimeoutMillis: 30000,
+                });
+                spanProcessors.push(otlpBatchProcessor);
+                logger.info(`${LOG_PREFIX} OTLP trace exporter added`, {
+                    endpoint: `${otlpEndpoint}/v1/traces`,
+                    serviceName,
+                });
+            }
+            catch (otlpError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP exporter (non-fatal)`, {
+                    error: otlpError instanceof Error
+                        ? otlpError.message
+                        : String(otlpError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+        }
         tracerProvider = new NodeTracerProvider({
             resource,
-            spanProcessors: [new ContextEnricher(), langfuseProcessor],
+            spanProcessors,
+        });
+        // Step 4: Register globally with explicit W3C propagator
+        // This ensures traceparent headers from calling SDKs are extracted correctly,
+        // even if another library registers a no-op propagator before us.
+        tracerProvider.register({
+            propagator: new W3CTraceContextPropagator(),
         });
-        // Step 4: Register globally
-        tracerProvider.register();
         usingExternalProvider = false;
         isInitialized = true;
-        logger.info(`${LOG_PREFIX} Initialized with Langfuse span processor`, {
+        // Step 5: If OTLP endpoint is set, also set up MeterProvider for metrics export
+        // This enables TelemetryService's metrics.getMeter() instruments to export via OTLP
+        if (otlpEndpoint) {
+            try {
+                const metricExporter = new OTLPMetricExporter({
+                    url: `${otlpEndpoint}/v1/metrics`,
+                });
+                const metricReader = new PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: 15000, // Export every 15 seconds
+                    exportTimeoutMillis: 10000,
+                });
+                meterProvider = new MeterProvider({
+                    resource,
+                    readers: [metricReader],
+                });
+                // Register globally so TelemetryService's metrics.getMeter() picks it up
+                metrics.setGlobalMeterProvider(meterProvider);
+                logger.info(`${LOG_PREFIX} OTLP metric exporter added — MeterProvider registered globally`, {
+                    endpoint: `${otlpEndpoint}/v1/metrics`,
+                    exportIntervalMs: 15000,
+                    serviceName,
+                    meterProviderType: meterProvider.constructor.name,
+                });
+            }
+            catch (metricsError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP metric exporter (non-fatal)`, {
+                    error: metricsError instanceof Error
+                        ? metricsError.message
+                        : String(metricsError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+            // Step 6: Set up LoggerProvider for OTLP log export
+            // This enables logRequest() to emit structured log records via OTLP
+            try {
+                const logExporter = new OTLPLogExporter({
+                    url: `${otlpEndpoint}/v1/logs`,
+                });
+                const logProcessor = new BatchLogRecordProcessor(logExporter, {
+                    maxQueueSize: 2048,
+                    maxExportBatchSize: 512,
+                    scheduledDelayMillis: 2000,
+                    exportTimeoutMillis: 30000,
+                });
+                loggerProvider = new LoggerProvider({
+                    resource,
+                    processors: [logProcessor],
+                });
+                logger.info(`${LOG_PREFIX} OTLP log exporter added — LoggerProvider created`, {
+                    endpoint: `${otlpEndpoint}/v1/logs`,
+                    serviceName,
+                });
+            }
+            catch (logsError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP log exporter (non-fatal)`, {
+                    error: logsError instanceof Error
+                        ? logsError.message
+                        : String(logsError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+        }
+        logger.info(`${LOG_PREFIX} Observability initialized`, {
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
             release: config.release || "v1.0.0",
             mode: "standalone",
+            langfuseEnabled: !!langfuseProcessor,
+            otlpEnabled: !!otlpEndpoint,
+            serviceName,
         });
     }
     catch (error) {
@@ -540,22 +670,75 @@ export async function flushOpenTelemetry() {
         logger.debug(`${LOG_PREFIX} Not initialized, skipping flush`);
         return;
     }
-    if (!langfuseProcessor) {
-        logger.debug(`${LOG_PREFIX} No processor to flush (Langfuse disabled)`);
-        return;
+    const failures = [];
+    if (langfuseProcessor) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing Langfuse spans...`);
+            await langfuseProcessor.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "langfuse", error });
+            logger.error(`${LOG_PREFIX} Langfuse flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
     }
-    try {
-        logger.info(`${LOG_PREFIX} Flushing pending spans to Langfuse...`);
-        await langfuseProcessor.forceFlush();
-        logger.info(`${LOG_PREFIX} Successfully flushed spans to Langfuse`);
+    else {
+        logger.debug(`${LOG_PREFIX} Langfuse disabled, skipping Langfuse flush`);
     }
-    catch (error) {
-        logger.error(`${LOG_PREFIX} Flush failed`, {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        throw error;
+    if (tracerProvider && !usingExternalProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP traces...`);
+            await tracerProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "traces", error });
+            logger.error(`${LOG_PREFIX} Trace flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No TracerProvider to flush`);
     }
+    if (meterProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP metrics...`);
+            await meterProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "metrics", error });
+            logger.error(`${LOG_PREFIX} Metric flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No MeterProvider to flush`);
+    }
+    if (loggerProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP logs...`);
+            await loggerProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "logs", error });
+            logger.error(`${LOG_PREFIX} Log flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No LoggerProvider to flush`);
+    }
+    if (failures.length > 0) {
+        throw new Error(`${LOG_PREFIX} Flush failed for: ${failures.map((f) => f.signal).join(", ")}`);
+    }
+    logger.info(`${LOG_PREFIX} Flush complete`);
 }
 /**
  * Shutdown OpenTelemetry and Langfuse span processor
@@ -577,7 +760,17 @@ export async function shutdownOpenTelemetry() {
         if (cachedContextEnricher) {
             await cachedContextEnricher.shutdown();
         }
+        // Shutdown MeterProvider if we created it
+        if (meterProvider) {
+            await meterProvider.shutdown();
+        }
+        // Shutdown LoggerProvider if we created it
+        if (loggerProvider) {
+            await loggerProvider.shutdown();
+        }
         tracerProvider = null;
+        meterProvider = null;
+        loggerProvider = null;
         langfuseProcessor = null;
         cachedContextEnricher = null;
         isInitialized = false;
@@ -603,6 +796,13 @@ export function getLangfuseSpanProcessor() {
 export function getTracerProvider() {
     return tracerProvider;
 }
+/**
+ * Get the logger provider for emitting OTLP log records.
+ * Returns null if OTLP is not configured or LoggerProvider was not created.
+ */
+export function getLoggerProvider() {
+    return loggerProvider;
+}
 /**
  * Check if OpenTelemetry is initialized
  */

package/dist/tasks/backends/bullmqBackend.d.ts

@@ -0,0 +1,33 @@
+/**
+ * BullMQ Backend — Production-grade task scheduling via Redis.
+ *
+ * - Cron tasks → BullMQ repeatable jobs with cron pattern
+ * - Interval tasks → BullMQ repeatable jobs with `every` option
+ * - One-shot tasks → BullMQ delayed jobs
+ * - Survives process restarts (Redis-persisted)
+ */
+import { type Task, type TaskBackend, type TaskExecutorFn, type TaskManagerConfig } from "../../types/taskTypes.js";
+export declare class BullMQBackend implements TaskBackend {
+    readonly name = "bullmq";
+    private queue;
+    private worker;
+    private executors;
+    private config;
+    constructor(config: TaskManagerConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    schedule(task: Task, executor: TaskExecutorFn): Promise<void>;
+    cancel(taskId: string): Promise<void>;
+    pause(taskId: string): Promise<void>;
+    resume(taskId: string): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    /**
+     * Returns a connection options object for BullMQ / ioredis.
+     * When a URL is provided we parse it fully, preserving TLS (`rediss://`),
+     * ACL username, password, db index, and any query-string parameters so
+     * nothing is silently dropped.
+     */
+    private getConnectionConfig;
+    private ensureInitialized;
+    private getQueue;
+}

package/dist/tasks/backends/bullmqBackend.js

@@ -0,0 +1,195 @@
+/**
+ * BullMQ Backend — Production-grade task scheduling via Redis.
+ *
+ * - Cron tasks → BullMQ repeatable jobs with cron pattern
+ * - Interval tasks → BullMQ repeatable jobs with `every` option
+ * - One-shot tasks → BullMQ delayed jobs
+ * - Survives process restarts (Redis-persisted)
+ */
+import { Queue, Worker } from "bullmq";
+import { logger } from "../../utils/logger.js";
+import { TaskError } from "../errors.js";
+import { TASK_DEFAULTS, } from "../../types/taskTypes.js";
+const QUEUE_NAME = "neurolink-tasks";
+export class BullMQBackend {
+    name = "bullmq";
+    queue = null;
+    worker = null;
+    executors = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async initialize() {
+        const connection = this.getConnectionConfig();
+        this.queue = new Queue(QUEUE_NAME, { connection });
+        this.worker = new Worker(QUEUE_NAME, async (job) => {
+            const taskId = job.data.taskId;
+            const task = job.data.task;
+            const executor = this.executors.get(taskId);
+            if (!executor) {
+                logger.warn("[BullMQ] No executor found for task", { taskId });
+                return;
+            }
+            logger.info("[BullMQ] Executing task", { taskId, name: task.name });
+            const result = await executor(task);
+            return result;
+        }, {
+            connection,
+            concurrency: this.config.maxConcurrentRuns ?? TASK_DEFAULTS.maxConcurrentRuns,
+        });
+        this.worker.on("failed", (job, err) => {
+            logger.error("[BullMQ] Job failed", {
+                taskId: job?.data?.taskId,
+                error: String(err),
+            });
+        });
+        this.worker.on("error", (err) => {
+            logger.error("[BullMQ] Worker error", { error: String(err) });
+        });
+        logger.info("[BullMQ] Backend initialized");
+    }
+    async shutdown() {
+        if (this.worker) {
+            await this.worker.close();
+            this.worker = null;
+        }
+        if (this.queue) {
+            await this.queue.close();
+            this.queue = null;
+        }
+        this.executors.clear();
+        logger.info("[BullMQ] Backend shut down");
+    }
+    async schedule(task, executor) {
+        const queue = this.getQueue();
+        this.executors.set(task.id, executor);
+        const jobData = { taskId: task.id, task };
+        const schedule = task.schedule;
+        if (schedule.type === "cron") {
+            await queue.upsertJobScheduler(task.id, {
+                pattern: schedule.expression,
+                ...(schedule.timezone ? { tz: schedule.timezone } : {}),
+            }, { name: task.name, data: jobData });
+        }
+        else if (schedule.type === "interval") {
+            await queue.upsertJobScheduler(task.id, { every: schedule.every }, { name: task.name, data: jobData });
+        }
+        else if (schedule.type === "once") {
+            const at = typeof schedule.at === "string" ? new Date(schedule.at) : schedule.at;
+            const delay = Math.max(0, at.getTime() - Date.now());
+            await queue.add(task.name, jobData, {
+                jobId: task.id,
+                delay,
+            });
+        }
+        logger.info("[BullMQ] Task scheduled", {
+            taskId: task.id,
+            type: schedule.type,
+        });
+    }
+    async cancel(taskId) {
+        const queue = this.getQueue();
+        this.executors.delete(taskId);
+        // Remove repeatable job scheduler
+        try {
+            await queue.removeJobScheduler(taskId);
+        }
+        catch {
+            // May not be a repeatable job — try removing by job ID
+        }
+        // Remove delayed/waiting job
+        try {
+            const job = await queue.getJob(taskId);
+            if (job) {
+                await job.remove();
+            }
+        }
+        catch {
+            // Job may already be processed/removed
+        }
+        logger.info("[BullMQ] Task cancelled", { taskId });
+    }
+    async pause(taskId) {
+        // BullMQ doesn't have per-job pause, so we fully cancel the job scheduler
+        // and executor. This is intentionally destructive — cancel() removes both
+        // the executor from the map and the job/scheduler from Redis.
+        //
+        // Resume flow (orchestrated by TaskManager):
+        //   1. TaskManager.resume() updates task status to "active" in the store
+        //   2. TaskManager.resume() calls backend.schedule(task, newExecutor)
+        //   3. schedule() re-registers the executor and creates a new job/scheduler
+        //
+        // Because TaskManager always supplies a fresh executor on schedule(),
+        // there is no need to preserve the old executor here.
+        await this.cancel(taskId);
+        logger.info("[BullMQ] Task paused (cancelled pending jobs; TaskManager will re-schedule on resume)", { taskId });
+    }
+    async resume(taskId) {
+        // No-op: BullMQ resume is handled by TaskManager calling schedule() after
+        // this method returns. See TaskManager.resume() which calls:
+        //   backend.schedule(updatedTask, executor)
+        // That call re-registers the executor and creates the job/scheduler in Redis.
+        logger.info("[BullMQ] Task resume requested (awaiting re-schedule from TaskManager)", { taskId });
+    }
+    async isHealthy() {
+        if (!this.queue) {
+            return false;
+        }
+        try {
+            // Check if the queue can reach Redis
+            await this.queue.getJobCounts();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── Internal ──────────────────────────────────────────
+    /**
+     * Returns a connection options object for BullMQ / ioredis.
+     * When a URL is provided we parse it fully, preserving TLS (`rediss://`),
+     * ACL username, password, db index, and any query-string parameters so
+     * nothing is silently dropped.
+     */
+    getConnectionConfig() {
+        const redis = this.config.redis ?? {};
+        if (redis.url) {
+            const parsed = new URL(redis.url);
+            const opts = {
+                host: parsed.hostname || "localhost",
+                port: Number(parsed.port) || 6379,
+                db: parsed.pathname ? Number(parsed.pathname.slice(1)) || 0 : 0,
+            };
+            if (parsed.password) {
+                opts.password = decodeURIComponent(parsed.password);
+            }
+            if (parsed.username) {
+                opts.username = decodeURIComponent(parsed.username);
+            }
+            // rediss:// scheme → enable TLS
+            if (parsed.protocol === "rediss:") {
+                opts.tls = {};
+            }
+            return opts;
+        }
+        return {
+            host: redis.host ?? TASK_DEFAULTS.redis.host,
+            port: redis.port ?? TASK_DEFAULTS.redis.port,
+            ...(redis.password ? { password: redis.password } : {}),
+            db: redis.db ?? 0,
+        };
+    }
+    ensureInitialized() {
+        if (!this.queue) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[BullMQ] Backend not initialized. Call initialize() first.");
+        }
+    }
+    getQueue() {
+        this.ensureInitialized();
+        if (!this.queue) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[BullMQ] Queue is unavailable after initialization.");
+        }
+        return this.queue;
+    }
+}

package/dist/tasks/backends/nodeTimeoutBackend.d.ts

@@ -0,0 +1,27 @@
+/**
+ * NodeTimeout Backend — Development/zero-dependency task scheduling.
+ *
+ * - Cron tasks → parsed with `croner`, scheduled via setTimeout chains
+ * - Interval tasks → setInterval
+ * - One-shot tasks → setTimeout
+ * - All timers are in-process — lost on restart
+ */
+import { type Task, type TaskBackend, type TaskExecutorFn, type TaskManagerConfig } from "../../types/taskTypes.js";
+export declare class NodeTimeoutBackend implements TaskBackend {
+    readonly name = "node-timeout";
+    private scheduled;
+    private paused;
+    private disposed;
+    private activeRuns;
+    private maxConcurrentRuns;
+    constructor(config: TaskManagerConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    schedule(task: Task, executor: TaskExecutorFn): Promise<void>;
+    cancel(taskId: string): Promise<void>;
+    pause(taskId: string): Promise<void>;
+    resume(taskId: string): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    private executeTask;
+    private clearEntry;
+}