botforje 0.0.1

package/dist/graph/executor.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphExecutor = void 0;
+const action_1 = require("../actions/action");
+const action_2 = require("../actions/action");
+const request_1 = require("../actions/request");
+const fuzzy_1 = require("../helpers/fuzzy");
+const logger_1 = require("../helpers/logger");
+class GraphExecutor {
+    constructor(actionCatalog, graphCatalog, graphStateService, outboxService, defaultTimeout = 300, cooldownService) {
+        this.actionCatalog = actionCatalog;
+        this.graphCatalog = graphCatalog;
+        this.graphStateService = graphStateService;
+        this.outboxService = outboxService;
+        this.defaultTimeout = defaultTimeout;
+        this.cooldownService = cooldownService;
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    updateCatalogs(actionCatalog, graphCatalog) {
+        this.actionCatalog = actionCatalog;
+        this.graphCatalog = graphCatalog;
+    }
+    clearBotSessions(botId) {
+        this.graphStateService.clearBotSessions(botId);
+    }
+    async handleMessage(bot, message) {
+        this.graphStateService.cleanupExpired();
+        const state = this.graphStateService.findActive(message.from, bot.id);
+        if (state) {
+            return this.handleActiveState(bot, message, state);
+        }
+        return this.handleNewSession(bot, message);
+    }
+    async handleNewSession(bot, message) {
+        const graphId = bot.graph;
+        if (!graphId) {
+            this.logger.error(`Bot "${bot.id}" has no graph assigned`);
+            return false;
+        }
+        const graph = this.graphCatalog.get(graphId);
+        if (!graph) {
+            this.logger.error(`Graph "${graphId}" referenced by bot "${bot.id}" not found`);
+            return false;
+        }
+        const rootNode = graph.nodes[graph.root];
+        if (!rootNode) {
+            this.logger.error(`Graph "${graph.id}" root node "${graph.root}" not found`);
+            return false;
+        }
+        if (graph.fallbackNode && !graph.nodes[graph.fallbackNode]) {
+            this.logger.error(`Graph "${graph.id}" fallback node "${graph.fallbackNode}" not found`);
+            return false;
+        }
+        const timeout = graph.timeout ?? this.defaultTimeout;
+        const state = this.graphStateService.create(message.from, bot.id, graph.id, graph.root, timeout, Date.now(), { __visitedNodes: [graph.root] });
+        this.logger.debug(`[new] graph="${graph.id}" root="${graph.root}" action="${rootNode.action}"`);
+        this.logger.debug(`  message: "${message.content}" from "${message.from}"`);
+        const rootConsumed = await this.executeNodeAction(bot, message, rootNode, {});
+        if (!rootConsumed) {
+            this.graphStateService.destroy(state.id);
+            return false;
+        }
+        return this.resolveFromActive(bot, message, state, graph);
+    }
+    async handleActiveState(bot, message, state) {
+        const graph = this.graphCatalog.get(state.graphId);
+        if (!graph) {
+            this.graphStateService.destroy(state.id);
+            return false;
+        }
+        const currentNode = graph.nodes[state.nodeId];
+        if (!currentNode) {
+            this.graphStateService.destroy(state.id);
+            return false;
+        }
+        this.logger.debug(`[active] graph="${graph.id}" node="${state.nodeId}" action="${currentNode.action}"`);
+        this.logger.debug(`  message: "${message.content}" from "${message.from}"`);
+        return this.resolveFromActive(bot, message, state, graph);
+    }
+    async resolveFromActive(bot, message, state, graph) {
+        const match = this.findBestEdge(graph, state, message.content);
+        if (!match) {
+            if (graph.fallbackNode && graph.nodes[graph.fallbackNode]) {
+                await this.transitionToNode(bot, message, state, graph, graph.fallbackNode);
+                return true;
+            }
+            this.logger.debug(`  no edge matched, staying on node "${state.nodeId}"`);
+            return true;
+        }
+        this.logger.debug(`  >> goto="${match.edge.goto}" | node=${match.nodeIndex} score=${match.score.toFixed(3)}`);
+        await this.transitionToNode(bot, message, state, graph, match.edge.goto);
+        return true;
+    }
+    async transitionToNode(bot, message, state, graph, nodeId) {
+        const node = graph.nodes[nodeId];
+        if (!node) {
+            this.logger.error(`Node "${nodeId}" not found in graph "${graph.id}"`);
+            this.graphStateService.destroy(state.id);
+            return;
+        }
+        const vars = { ...state.variables };
+        const visited = vars.__visitedNodes ?? [];
+        if (nodeId === graph.root) {
+            vars.__visitedNodes = [graph.root];
+        }
+        else if (nodeId !== state.nodeId) {
+            const prevNode = graph.nodes[state.nodeId];
+            const hasNavEdges = prevNode?.edges.some(e => e.match && e.match.length > 0);
+            if (hasNavEdges) {
+                if (visited.includes(state.nodeId)) {
+                    const reordered = visited.filter(n => n !== state.nodeId);
+                    vars.__visitedNodes = [...reordered, state.nodeId];
+                }
+                else {
+                    vars.__visitedNodes = [...visited, state.nodeId];
+                }
+            }
+        }
+        await this.executeNodeAction(bot, message, node, vars);
+        this.graphStateService.updateStep(state.id, nodeId, vars);
+        this.logger.debug(`  visited updated: [${(vars.__visitedNodes ?? []).join(', ')}]`);
+    }
+    findBestEdge(graph, state, message) {
+        const visited = state.variables?.__visitedNodes ?? [];
+        const currentNode = graph.nodes[state.nodeId];
+        if (!currentNode)
+            return null;
+        this.logger.debug(`  context: "${message}"`);
+        this.logger.debug(`  current: ${state.nodeId} | visited: [${visited.join(', ')}]`);
+        const nodes = [];
+        const allNodeNames = [...new Set([...visited, state.nodeId])];
+        for (const nodeName of allNodeNames) {
+            const node = graph.nodes[nodeName];
+            if (node && nodeName !== state.nodeId) {
+                nodes.push({ edges: node.edges, nodeName });
+            }
+        }
+        nodes.push({ edges: currentNode.edges, nodeName: state.nodeId });
+        let best = null;
+        for (let ni = 0; ni < nodes.length; ni++) {
+            const node = nodes[ni];
+            const edgeList = node.edges || [];
+            const condEdges = edgeList.filter(e => e.match && e.match.length > 0);
+            if (condEdges.length === 0) {
+                this.logger.debug(`    Node ${ni} ${node.nodeName}: 0 conditional edges`);
+                continue;
+            }
+            this.logger.debug(`    Node ${ni} ${node.nodeName} — ${condEdges.length} edges:`);
+            for (let ei = 0; ei < condEdges.length; ei++) {
+                const edge = condEdges[ei];
+                const threshold = edge.fuzzyThreshold ?? 0.6;
+                const result = (0, fuzzy_1.matchFuzzyVerbose)(edge.match, message, threshold);
+                if (!result) {
+                    this.logger.debug(`      [${ei}] match="${edge.match}" → ${edge.goto}`);
+                    continue;
+                }
+                const isBest = !best ||
+                    result.score < best.score ||
+                    (result.score === best.score && ni > best.nodeIndex);
+                const marker = isBest ? '◀ BEST' : '◀ worse';
+                this.logger.debug(`      [${ei}] match="${edge.match}" → ${edge.goto} | match="${result.match}" score=${result.score.toFixed(3)} ${marker}`);
+                if (isBest) {
+                    best = { edge, score: result.score, nodeIndex: ni };
+                }
+            }
+        }
+        if (best) {
+            this.logger.debug(`    >> winner: Node ${best.nodeIndex} goto="${best.edge.goto}" score=${best.score.toFixed(3)}`);
+            return best;
+        }
+        const defaultEdge = currentNode.edges.find(e => !e.match || e.match.length === 0);
+        if (defaultEdge) {
+            this.logger.debug(`    >> default → goto="${defaultEdge.goto}"`);
+            return { edge: defaultEdge, score: 1, nodeIndex: nodes.length - 1 };
+        }
+        this.logger.debug(`    >> no match`);
+        return null;
+    }
+    async executeNodeAction(bot, message, node, variables) {
+        const context = {
+            botId: bot.id,
+            botName: bot.id,
+            senderPhone: message.from,
+            senderName: message.senderName,
+            message: message.content,
+            variables,
+        };
+        const action = (0, action_1.resolveAction)(this.actionCatalog, node.action);
+        if (this.isActionOnCooldown(action, message.from)) {
+            const onBlockedExecutedKey = `on_blocked.executed:${action.id}`;
+            const cooldown = action.guards?.cooldown;
+            if (cooldown && this.cooldownService?.isOnCooldown(message.from, onBlockedExecutedKey, cooldown.duration * 1000)) {
+                this.logger.debug(`  on_blocked pipeline already ran this cooldown for action "${node.action}", skipping`);
+                return true;
+            }
+            const onBlocked = action.guards?.cooldown?.onBlocked;
+            if (onBlocked && onBlocked.length > 0) {
+                for (const step of onBlocked) {
+                    await this.runStep(bot, message, step, context);
+                }
+                this.cooldownService?.setCooldown(message.from, onBlockedExecutedKey);
+                this.logger.info(`Cooldown on_blocked pipeline ran for action "${node.action}" to ${message.from}`);
+            }
+            else {
+                this.logger.warn(`Action "${node.action}" on cooldown, no on_blocked defined, skipping`);
+            }
+            return true;
+        }
+        for (const step of action.steps) {
+            await this.runStep(bot, message, step, context);
+        }
+        this.setActionCooldown(action, message.from);
+        this.cooldownService?.removeCooldown(message.from, `on_blocked.executed:${action.id}`);
+        return true;
+    }
+    async runStep(bot, message, step, context) {
+        if ('message' in step) {
+            const to = step.message.to ? (0, action_2.resolveVars)(step.message.to, context) : message.from;
+            const text = (0, action_2.resolveVars)(step.message.body, context);
+            this.outboxService.enqueue(bot.id, to, text);
+            this.logger.debug(`  message step → to=${to} text="${text.substring(0, 40)}"`);
+            return;
+        }
+        if ('location' in step) {
+            this.outboxService.enqueue(bot.id, message.from, '', {
+                type: 'location',
+                latitude: step.location.latitude,
+                longitude: step.location.longitude,
+                name: step.location.name,
+                address: step.location.address,
+                url: step.location.url,
+                description: step.location.description,
+            });
+            this.logger.debug(`  location step → lat=${step.location.latitude} lng=${step.location.longitude}`);
+            return;
+        }
+        if ('request' in step) {
+            const resolvedUrl = (0, action_2.resolveVars)(step.request.url, context);
+            try {
+                const payload = this.buildRequestPayload(bot, message, step.request.name || 'unnamed');
+                await (0, request_1.sendRequest)({
+                    url: resolvedUrl,
+                    method: step.request.method,
+                    headers: step.request.headers,
+                    body: payload,
+                    timeout: step.request.timeout,
+                    retries: step.request.retries,
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Failed to execute request step for bot "${bot.id}" url="${resolvedUrl}": ${msg}`);
+            }
+            return;
+        }
+    }
+    isActionOnCooldown(action, sender) {
+        if (!this.cooldownService) {
+            return false;
+        }
+        const cooldown = action.guards?.cooldown;
+        if (!cooldown || cooldown.duration <= 0) {
+            return false;
+        }
+        const cooldownMs = cooldown.duration * 1000;
+        const cooldownKey = `action:${action.id}`;
+        return this.cooldownService.isOnCooldown(sender, cooldownKey, cooldownMs);
+    }
+    setActionCooldown(action, sender) {
+        if (!this.cooldownService) {
+            return;
+        }
+        const cooldown = action.guards?.cooldown;
+        if (!cooldown || cooldown.duration <= 0) {
+            return;
+        }
+        this.cooldownService.setCooldown(sender, `action:${action.id}`);
+    }
+    buildRequestPayload(bot, message, requestName) {
+        return {
+            senderPhone: message.from,
+            senderName: message.senderName,
+            message: message.content,
+            timestamp: message.timestamp.toISOString(),
+            botId: bot.id,
+            botName: bot.id,
+            requestName,
+            metadata: message.metadata || {},
+        };
+    }
+}
+exports.GraphExecutor = GraphExecutor;

package/dist/graph/graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/graph/state.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphStateService = void 0;
+const node_sqlite_1 = require("node:sqlite");
+class GraphStateService {
+    constructor(dbPath) {
+        this.db = new node_sqlite_1.DatabaseSync(dbPath);
+        this.setupSchema();
+    }
+    setupSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS graph_states (
+        id TEXT PRIMARY KEY,
+        sender TEXT NOT NULL,
+        bot_id TEXT NOT NULL,
+        graph_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        variables TEXT NOT NULL DEFAULT '{}',
+        started_at INTEGER NOT NULL,
+        last_activity_at INTEGER NOT NULL,
+        timeout INTEGER NOT NULL
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_graph_states_sender_bot ON graph_states(sender, bot_id);
+      CREATE INDEX IF NOT EXISTS idx_graph_states_last_activity ON graph_states(last_activity_at);
+    `);
+    }
+    findActive(sender, botId, now = Date.now()) {
+        const row = this.db
+            .prepare('SELECT * FROM graph_states WHERE sender = ? AND bot_id = ?')
+            .get(sender, botId);
+        if (!row) {
+            return null;
+        }
+        const state = this.rowToState(row);
+        if (this.isExpired(state, now)) {
+            this.destroy(state.id);
+            return null;
+        }
+        return state;
+    }
+    create(sender, botId, graphId, nodeId, timeout, now = Date.now(), initialVariables) {
+        this.destroyBySenderBot(sender, botId);
+        const id = `${botId}-${sender}-${now}`;
+        const state = {
+            id,
+            sender,
+            botId,
+            graphId,
+            nodeId,
+            variables: { ...initialVariables },
+            startedAt: now,
+            lastActivityAt: now,
+            timeout,
+        };
+        this.db
+            .prepare('INSERT INTO graph_states (id, sender, bot_id, graph_id, node_id, variables, started_at, last_activity_at, timeout) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(state.id, state.sender, state.botId, state.graphId, state.nodeId, JSON.stringify(state.variables), state.startedAt, state.lastActivityAt, state.timeout);
+        return state;
+    }
+    updateStep(id, nodeId, variables, now = Date.now()) {
+        const state = this.findById(id);
+        if (!state) {
+            return;
+        }
+        const mergedVariables = variables ? { ...state.variables, ...variables } : state.variables;
+        this.db
+            .prepare('UPDATE graph_states SET node_id = ?, variables = ?, last_activity_at = ? WHERE id = ?')
+            .run(nodeId, JSON.stringify(mergedVariables), now, id);
+    }
+    destroy(id) {
+        this.db.prepare('DELETE FROM graph_states WHERE id = ?').run(id);
+    }
+    destroyBySenderBot(sender, botId) {
+        this.db.prepare('DELETE FROM graph_states WHERE sender = ? AND bot_id = ?').run(sender, botId);
+    }
+    clearBotSessions(botId) {
+        this.db.prepare('DELETE FROM graph_states WHERE bot_id = ?').run(botId);
+    }
+    cleanupExpired(now = Date.now()) {
+        const cutoff = now;
+        const result = this.db
+            .prepare('DELETE FROM graph_states WHERE (last_activity_at + (timeout * 1000)) < ?')
+            .run(cutoff);
+        return Number(result.changes);
+    }
+    count() {
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM graph_states').get();
+        return row.count;
+    }
+    close() {
+        this.db.close();
+    }
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM graph_states WHERE id = ?').get(id);
+        return row ? this.rowToState(row) : null;
+    }
+    rowToState(row) {
+        return {
+            id: row.id,
+            sender: row.sender,
+            botId: row.bot_id,
+            graphId: row.graph_id,
+            nodeId: row.node_id,
+            variables: JSON.parse(row.variables || '{}'),
+            startedAt: row.started_at,
+            lastActivityAt: row.last_activity_at,
+            timeout: row.timeout,
+        };
+    }
+    isExpired(state, now) {
+        if (state.timeout <= 0) {
+            return false;
+        }
+        return now > state.lastActivityAt + state.timeout * 1000;
+    }
+}
+exports.GraphStateService = GraphStateService;

package/dist/helpers/data.js

@@ -0,0 +1,42 @@
+"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.getDataDir = getDataDir;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function getDataDir() {
+    const dataHome = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
+    return path.join(dataHome, 'botforje');
+}

package/dist/helpers/fuzzy.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchFuzzy = matchFuzzy;
+exports.matchFuzzyVerbose = matchFuzzyVerbose;
+const fuse_js_1 = __importDefault(require("fuse.js"));
+function matchFuzzy(segments, message, threshold) {
+    const result = matchFuzzyVerbose(segments, message, threshold);
+    return result?.match || null;
+}
+function matchFuzzyVerbose(segments, message, threshold) {
+    if (segments.length === 0)
+        return null;
+    const fuse = new fuse_js_1.default(segments, {
+        includeScore: true,
+        threshold,
+    });
+    const results = fuse.search(message);
+    if (results.length > 0 && results[0].score !== undefined && results[0].score <= threshold) {
+        return {
+            match: segments[results[0].refIndex],
+            phrase: message,
+            score: results[0].score,
+            threshold,
+        };
+    }
+    return null;
+}

package/dist/helpers/logger.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = void 0;
+exports.createLogger = createLogger;
+exports.getLogger = getLogger;
+exports.setGlobalLogger = setGlobalLogger;
+const pino_1 = __importDefault(require("pino"));
+function getCallerInfo() {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    if (!isDevelopment)
+        return undefined;
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+        const err = new Error();
+        Error.prepareStackTrace = (_, stack) => stack;
+        const stack = err.stack;
+        const caller = stack[2];
+        if (caller) {
+            const fileName = caller.getFileName() || 'unknown';
+            const lineNumber = caller.getLineNumber() || 0;
+            const functionName = caller.getFunctionName() || 'anonymous';
+            const shortFileName = fileName.split('/').pop() || fileName;
+            return {
+                file: shortFileName,
+                line: lineNumber,
+                func: functionName,
+            };
+        }
+    }
+    catch (e) {
+    }
+    finally {
+        Error.prepareStackTrace = originalPrepareStackTrace;
+    }
+    return undefined;
+}
+function createLogger(logLevel = 'info') {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    const logger = (0, pino_1.default)({
+        level: logLevel,
+        transport: isDevelopment
+            ? {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss',
+                    ignore: 'pid,hostname,caller',
+                    messageFormat: '{if caller}[{caller.file}:{caller.line}]{end} {msg}',
+                    singleLine: false,
+                    hideObject: true,
+                },
+            }
+            : undefined,
+        formatters: {
+            level: label => ({ level: label }),
+        },
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    });
+    return {
+        debug: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.debug({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+        info: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.info({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+        warn: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.warn({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+        error: (message, ...args) => {
+            const caller = getCallerInfo();
+            logger.error({ ...(args.length > 0 ? { args } : {}), ...(caller ? { caller } : {}) }, message);
+        },
+    };
+}
+let globalLogger = createLogger('info');
+function getLogger() {
+    return globalLogger;
+}
+function setGlobalLogger(config) {
+    const logLevel = config?.log_level || 'info';
+    globalLogger = createLogger(logLevel);
+}
+exports.defaultLogger = createLogger('info');

package/dist/helpers/validation.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateId = validateId;
+exports.validatePriority = validatePriority;
+exports.validateTypingDelay = validateTypingDelay;
+exports.validateQueueDelay = validateQueueDelay;
+function validateId(id, kind) {
+    if (!id || id.length < 3) {
+        throw new Error(`${kind} ID must be at least 3 characters long`);
+    }
+    if (!/^[a-z0-9-]+$/.test(id)) {
+        throw new Error(`${kind} ID can only contain lowercase letters, numbers and hyphens`);
+    }
+    if (/^[-]/.test(id)) {
+        throw new Error(`${kind} ID cannot start with a hyphen`);
+    }
+    if (/[-]$/.test(id)) {
+        throw new Error(`${kind} ID cannot end with a hyphen`);
+    }
+    if (/--/.test(id)) {
+        throw new Error(`${kind} ID cannot contain consecutive hyphens`);
+    }
+}
+function validatePriority(priority) {
+    if (priority < 0) {
+        throw new Error('Priority must be non-negative');
+    }
+}
+function validateTypingDelay(delay) {
+    if (delay < 0) {
+        throw new Error('Typing delay must be non-negative');
+    }
+}
+function validateQueueDelay(delay) {
+    if (delay < 0) {
+        throw new Error('Queue delay must be non-negative');
+    }
+}