@hotmeshio/long-tail 0.1.0

package/build/routes/yaml-workflows/crud.js

@@ -0,0 +1,276 @@
+"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 });
+const express_1 = require("express");
+const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
+const yamlGenerator = __importStar(require("../../services/yaml-workflow/generator"));
+const task_1 = require("../../services/task");
+const helpers_1 = require("./helpers");
+const router = (0, express_1.Router)();
+/**
+ * GET /api/yaml-workflows
+ * List YAML workflows with optional status filter.
+ */
+router.get('/', async (req, res) => {
+    try {
+        const result = await yamlDb.listYamlWorkflows({
+            status: req.query.status,
+            graph_topic: req.query.graph_topic,
+            app_id: req.query.app_id,
+            search: req.query.search,
+            source_workflow_id: req.query.source_workflow_id,
+            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/yaml-workflows
+ * Generate a YAML workflow from a completed execution.
+ * Body: { workflow_id, task_queue, workflow_name, name, description? }
+ */
+router.post('/', async (req, res) => {
+    try {
+        const { workflow_id, task_queue, workflow_name, name, description, app_id, subscribes, tags: userTags, compilation_feedback } = req.body;
+        if (!workflow_id || !task_queue || !workflow_name || !name) {
+            res.status(400).json({
+                error: 'workflow_id, task_queue, workflow_name, and name are required',
+            });
+            return;
+        }
+        // Reject compilation of executions that exhausted their tool rounds —
+        // the trace is incomplete and would produce a broken workflow.
+        const task = await (0, task_1.getTaskByWorkflowId)(workflow_id);
+        if (task) {
+            const milestones = task.milestones ?? [];
+            const roundsExhausted = milestones.some((m) => m.name === 'rounds_exhausted');
+            if (roundsExhausted) {
+                res.status(422).json({
+                    error: 'Cannot compile: the source execution exhausted its tool rounds without completing the task. Resolve the escalation and resubmit.',
+                });
+                return;
+            }
+        }
+        // Generate YAML from execution
+        const result = await yamlGenerator.generateYamlFromExecution({
+            workflowId: workflow_id,
+            taskQueue: task_queue,
+            workflowName: workflow_name,
+            name,
+            description,
+            appId: app_id,
+            subscribes,
+            compilationFeedback: compilation_feedback,
+        });
+        // Merge auto-derived tags with user-provided tags
+        const mergedTags = [...new Set([...(result.tags || []), ...(Array.isArray(userTags) ? userTags : [])])];
+        // Store in DB
+        const record = await yamlDb.createYamlWorkflow({
+            name,
+            description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: mergedTags,
+            source_workflow_id: workflow_id,
+            source_workflow_type: workflow_name,
+            original_prompt: result.originalPrompt || undefined,
+            category: result.category || undefined,
+            metadata: {
+                input_field_meta: result.inputFieldMeta,
+                ...(result.validationIssues?.length ? { validation_warnings: result.validationIssues } : {}),
+            },
+        });
+        res.status(201).json(record);
+    }
+    catch (err) {
+        if (err.message?.includes('duplicate key') || err.code === '23505') {
+            res.status(409).json({ error: 'A YAML workflow with that name already exists' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/yaml-workflows/app-ids
+ * Return distinct app_id values from non-archived workflows.
+ */
+router.get('/app-ids', async (_req, res) => {
+    try {
+        const appIds = await yamlDb.getDistinctAppIds();
+        res.json({ app_ids: appIds });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// -- Parameterized routes --
+/**
+ * GET /api/yaml-workflows/:id
+ * Get a single YAML workflow.
+ */
+router.get('/:id', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.json(wf);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * PUT /api/yaml-workflows/:id
+ * Update a YAML workflow's metadata.
+ */
+router.put('/:id', async (req, res) => {
+    try {
+        const wf = await yamlDb.updateYamlWorkflow(req.params.id, req.body);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.json(wf);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/yaml-workflows/:id/regenerate
+ * Re-generate the YAML from the original source execution.
+ * Only allowed for non-archived workflows.
+ */
+router.post('/:id/regenerate', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        if (wf.status === 'archived') {
+            res.status(400).json({ error: 'Archived workflows cannot be regenerated' });
+            return;
+        }
+        if (!wf.source_workflow_id || !wf.source_workflow_type) {
+            res.status(400).json({ error: 'Missing source workflow reference — cannot regenerate' });
+            return;
+        }
+        // Look up task queue from the source task record, or use body override
+        let taskQueue = req.body.task_queue;
+        if (!taskQueue) {
+            const sourceTask = await (0, task_1.getTaskByWorkflowId)(wf.source_workflow_id);
+            taskQueue = sourceTask?.task_queue || 'v1';
+        }
+        const feedback = req.body.compilation_feedback;
+        const result = await yamlGenerator.generateYamlFromExecution({
+            workflowId: wf.source_workflow_id,
+            taskQueue,
+            workflowName: wf.source_workflow_type,
+            name: wf.name,
+            description: wf.description || undefined,
+            appId: wf.app_id,
+            compilationFeedback: feedback || undefined,
+            priorFailedYaml: feedback ? wf.yaml_content : undefined,
+        });
+        const updated = await yamlDb.updateYamlWorkflow(wf.id, {
+            app_id: result.appId,
+            graph_topic: result.graphTopic,
+            yaml_content: result.yaml,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: result.tags,
+            metadata: { input_field_meta: result.inputFieldMeta },
+        });
+        res.json(updated);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * DELETE /api/yaml-workflows/:id
+ * Delete a YAML workflow (must be draft or archived).
+ */
+router.delete('/:id', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        if (wf.status === 'active' || wf.status === 'deployed') {
+            res.status(400).json({ error: 'Cannot delete an active or deployed workflow. Archive it first.' });
+            return;
+        }
+        await yamlDb.deleteYamlWorkflow(req.params.id);
+        res.json({ deleted: true });
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/yaml-workflows/deployment.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/yaml-workflows/deployment.js

@@ -0,0 +1,179 @@
+"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 });
+const express_1 = require("express");
+const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
+const yamlDeployer = __importStar(require("../../services/yaml-workflow/deployer"));
+const yamlWorkers = __importStar(require("../../services/yaml-workflow/workers"));
+const helpers_1 = require("./helpers");
+const router = (0, express_1.Router)();
+/**
+ * POST /api/yaml-workflows/:id/deploy
+ * Deploy all YAML workflows sharing this workflow's app_id as a merged version.
+ * Bumps the version and deploys all graphs together.
+ */
+router.post('/:id/deploy', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        // Use the version declared in the YAML (like package.json)
+        const deployVersion = wf.app_version || '1';
+        // Deploy + activate merged YAML for the full app_id
+        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
+        await yamlDeployer.deployAppId(wf.app_id, deployVersion);
+        // Register workers and mark all non-archived siblings as active
+        for (const sibling of siblings) {
+            await yamlDb.updateYamlWorkflowVersion(sibling.id, deployVersion);
+            await yamlWorkers.registerWorkersForWorkflow(sibling);
+            if (sibling.status === 'draft' || sibling.status === 'deployed') {
+                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
+            }
+        }
+        // Mark content as deployed for the entire app_id
+        await yamlDb.markAppIdContentDeployed(wf.app_id);
+        const updated = await yamlDb.getYamlWorkflow(req.params.id);
+        res.json(updated);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({
+            error: err.message,
+            hint: err.message.includes('Duplicate activity id')
+                ? 'Colliding activity IDs across workflows. A Claude Code repair was attempted — check server logs. You may need to archive conflicting workflows and recompile.'
+                : undefined,
+        });
+    }
+});
+/**
+ * POST /api/yaml-workflows/:id/activate
+ * Activate the deployed version for this workflow's app_id and register all workers.
+ */
+router.post('/:id/activate', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        if (wf.status !== 'deployed' && wf.status !== 'active') {
+            res.status(400).json({ error: 'Workflow must be deployed before activation' });
+            return;
+        }
+        await yamlDeployer.activateYamlWorkflow(wf.app_id, wf.app_version);
+        // Register workers for ALL workflows sharing this app_id
+        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
+        for (const sibling of siblings) {
+            await yamlWorkers.registerWorkersForWorkflow(sibling);
+            if (sibling.status === 'deployed') {
+                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
+            }
+        }
+        const updated = await yamlDb.getYamlWorkflow(req.params.id);
+        res.json(updated);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/yaml-workflows/:id/invoke
+ * Invoke an active YAML workflow with parameters.
+ * Body: { data, sync?: boolean }
+ */
+router.post('/:id/invoke', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        if (wf.status !== 'active') {
+            res.status(400).json({ error: 'Workflow must be active to invoke' });
+            return;
+        }
+        const data = req.body.data || {};
+        if (req.body.sync) {
+            const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, data, req.body.timeout, wf.graph_topic);
+            res.json({ job_id, result });
+        }
+        else {
+            const jobId = await yamlDeployer.invokeYamlWorkflow(wf.app_id, wf.graph_topic, data, wf.graph_topic);
+            res.json({ job_id: jobId });
+        }
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/yaml-workflows/:id/archive
+ * Archive a YAML workflow (stops accepting new invocations).
+ */
+router.post('/:id/archive', async (req, res) => {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        if (wf.status === 'active') {
+            await yamlDeployer.stopEngine(wf.app_id);
+        }
+        const updated = await yamlDb.updateYamlWorkflowStatus(wf.id, 'archived');
+        res.json(updated);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/yaml-workflows/helpers.d.ts

@@ -0,0 +1,2 @@
+/** Return true if a Postgres error indicates an invalid/missing ID */
+export declare function isNotFoundError(err: any): boolean;

package/build/routes/yaml-workflows/helpers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotFoundError = isNotFoundError;
+/** Return true if a Postgres error indicates an invalid/missing ID */
+function isNotFoundError(err) {
+    const msg = err?.message ?? '';
+    return msg.includes('invalid input syntax for type uuid') || msg.includes('not found');
+}

package/build/routes/yaml-workflows/index.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/yaml-workflows/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const crud_1 = __importDefault(require("./crud"));
+const deployment_1 = __importDefault(require("./deployment"));
+const versions_1 = __importDefault(require("./versions"));
+const router = (0, express_1.Router)();
+// Mount in the same order as the original monolithic file.
+// crud.ts handles: GET /, POST /, GET /app-ids, GET /:id, PUT /:id,
+//                  POST /:id/regenerate, DELETE /:id
+router.use(crud_1.default);
+// deployment.ts handles: POST /:id/deploy, POST /:id/activate,
+//                        POST /:id/invoke, POST /:id/archive
+router.use(deployment_1.default);
+// versions.ts handles: GET /:id/versions, GET /:id/versions/:version,
+//                      GET /:id/yaml
+router.use(versions_1.default);
+exports.default = router;

package/build/routes/yaml-workflows/versions.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/yaml-workflows/versions.js

@@ -0,0 +1,116 @@
+"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 });
+const express_1 = require("express");
+const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
+const helpers_1 = require("./helpers");
+const router = (0, express_1.Router)();
+/**
+ * GET /api/yaml-workflows/:id/versions
+ * Return version history for a YAML workflow.
+ */
+router.get('/:id/versions', async (req, res) => {
+    try {
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 20;
+        const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
+        const result = await yamlDb.getVersionHistory(req.params.id, limit, offset);
+        res.json(result);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/yaml-workflows/:id/versions/:version
+ * Return a single version snapshot with YAML, schemas, and manifest.
+ */
+router.get('/:id/versions/:version', async (req, res) => {
+    try {
+        const version = parseInt(req.params.version, 10);
+        if (isNaN(version) || version < 1) {
+            res.status(400).json({ error: 'Invalid version number' });
+            return;
+        }
+        const snapshot = await yamlDb.getVersionSnapshot(req.params.id, version);
+        if (!snapshot) {
+            res.status(404).json({ error: `Version ${version} not found` });
+            return;
+        }
+        res.json(snapshot);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/yaml-workflows/:id/yaml
+ * Return raw YAML content. Supports ?version=N query param.
+ */
+router.get('/:id/yaml', async (req, res) => {
+    try {
+        const versionParam = req.query.version ? parseInt(req.query.version, 10) : null;
+        if (versionParam) {
+            const snapshot = await yamlDb.getVersionSnapshot(req.params.id, versionParam);
+            if (!snapshot) {
+                res.status(404).json({ error: `Version ${versionParam} not found` });
+                return;
+            }
+            res.type('text/yaml').send(snapshot.yaml_content);
+            return;
+        }
+        const wf = await yamlDb.getYamlWorkflow(req.params.id);
+        if (!wf) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.type('text/yaml').send(wf.yaml_content);
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            res.status(404).json({ error: 'YAML workflow not found' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/scripts/process-helpers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared helpers for the end-to-end process runner.
+ */
+export declare function setBase(url: string): void;
+export declare function getBase(): string;
+export declare function log(role: string, msg: string): void;
+export declare function header(text: string): void;
+export declare function api(method: string, path: string, token: string, body?: Record<string, any>): Promise<any>;
+export declare function login(username: string, password: string): Promise<string>;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function poll<T>(label: string, fn: () => Promise<T | null>, timeoutMs?: number, intervalMs?: number): Promise<T>;