@rhq/rover 0.0.0-stage → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +384 -2
- package/Rover.podspec +32 -0
- package/android/CMakeLists.txt +32 -0
- package/android/build.gradle +77 -0
- package/android/src/main/AndroidManifest.xml +3 -0
- package/android/src/main/cpp/rover-jni.cpp +15 -0
- package/android/src/main/java/com/relayhq/rover/RoverJsiModule.kt +16 -0
- package/android/src/main/java/com/relayhq/rover/RoverModule.kt +56 -0
- package/android/src/main/java/com/relayhq/rover/RoverNativeBridge.kt +45 -0
- package/android/src/main/java/com/relayhq/rover/RoverNativeModule.kt +73 -0
- package/android/src/main/java/com/relayhq/rover/RoverPackage.kt +16 -0
- package/android/src/main/java/uniffi/relay_rover/relay_rover.kt +1089 -0
- package/android/src/main/jniLibs/arm64-v8a/librelay_rover.so +0 -0
- package/android/src/main/jniLibs/armeabi-v7a/librelay_rover.so +0 -0
- package/android/src/main/jniLibs/x86_64/librelay_rover.so +0 -0
- package/cpp/RoverJsi.cpp +156 -0
- package/cpp/RoverJsi.h +20 -0
- package/eng/relay_rover.wasm +0 -0
- package/expo-module.config.json +10 -0
- package/index.d.ts +204 -0
- package/index.js +425 -0
- package/index.native.js +476 -0
- package/ios/Rover-Bridging-Header.h +1 -0
- package/ios/RoverBridge.mm +117 -0
- package/ios/RoverModule.swift +54 -0
- package/ios/relay_rover.swift +623 -0
- package/ios/relay_roverFFI.h +589 -0
- package/ios/relay_roverFFI.modulemap +7 -0
- package/package.json +48 -4
package/index.js
ADDED
|
@@ -0,0 +1,425 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @rhq/rover (Relay Rover)
|
|
3
|
+
* High-performance WebAssembly Email Intelligence Engine for React Native and JavaScript.
|
|
4
|
+
* Zero-dependency, in-memory execution powered by compiled Rust WASM.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import fs from 'fs';
|
|
8
|
+
import path from 'path';
|
|
9
|
+
import { fileURLToPath } from 'url';
|
|
10
|
+
|
|
11
|
+
let wasmInstance = null;
|
|
12
|
+
let wasmExports = null;
|
|
13
|
+
let memory = null;
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* Ensure the WASM engine is loaded and initialized.
|
|
17
|
+
* Can be called explicitly with custom bytes or lazy-initializes on first call.
|
|
18
|
+
*
|
|
19
|
+
* @param {ArrayBuffer|Uint8Array} [customBytes] Optional custom WASM binary buffer
|
|
20
|
+
*/
|
|
21
|
+
export function init(customBytes) {
|
|
22
|
+
if (wasmExports) {
|
|
23
|
+
return wasmExports;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
let bytes = customBytes;
|
|
27
|
+
|
|
28
|
+
if (!bytes) {
|
|
29
|
+
// 1. Try reading from eng/relay_rover.wasm relative to this module
|
|
30
|
+
try {
|
|
31
|
+
const __filename = fileURLToPath(import.meta.url);
|
|
32
|
+
const __dirname = path.dirname(__filename);
|
|
33
|
+
const wasmPath = path.resolve(__dirname, 'eng/relay_rover.wasm');
|
|
34
|
+
if (fs.existsSync(wasmPath)) {
|
|
35
|
+
bytes = fs.readFileSync(wasmPath);
|
|
36
|
+
}
|
|
37
|
+
} catch (_) { }
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
if (!bytes) {
|
|
41
|
+
// 2. Try global WASM binary if injected by React Native or bundler
|
|
42
|
+
if (typeof globalThis !== 'undefined' && globalThis.__RELAY_ROVER_WASM__) {
|
|
43
|
+
bytes = globalThis.__RELAY_ROVER_WASM__;
|
|
44
|
+
}
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
if (!bytes) {
|
|
48
|
+
throw new Error(
|
|
49
|
+
'Relay Rover WASM engine binary not found. Call RelayRover.init(wasmBytes) or ensure eng/relay_rover.wasm is present.'
|
|
50
|
+
);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
const module = new WebAssembly.Module(bytes);
|
|
54
|
+
wasmInstance = new WebAssembly.Instance(module, {});
|
|
55
|
+
wasmExports = wasmInstance.exports;
|
|
56
|
+
memory = wasmExports.memory;
|
|
57
|
+
return wasmExports;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function getExports() {
|
|
61
|
+
if (!wasmExports) {
|
|
62
|
+
init();
|
|
63
|
+
}
|
|
64
|
+
return wasmExports;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
function writeStringToMemory(exp, mem, str) {
|
|
68
|
+
const encoder = new TextEncoder();
|
|
69
|
+
const encoded = encoder.encode(str || '');
|
|
70
|
+
const ptr = exp.rover_alloc(encoded.length);
|
|
71
|
+
const heap = new Uint8Array(mem.buffer, ptr, encoded.length);
|
|
72
|
+
heap.set(encoded);
|
|
73
|
+
return { ptr, len: encoded.length };
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
function readStringFromMemory(exp, mem, ptr) {
|
|
77
|
+
const view = new DataView(mem.buffer, ptr);
|
|
78
|
+
const len = view.getUint32(0, true);
|
|
79
|
+
const bytes = new Uint8Array(mem.buffer, ptr + 4, len);
|
|
80
|
+
const text = new TextDecoder('utf-8').decode(bytes);
|
|
81
|
+
exp.rover_dealloc(ptr, len + 4);
|
|
82
|
+
return text;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/**
|
|
86
|
+
* Convert HTML email content to clean, readable plain text.
|
|
87
|
+
* Strips script tags, style blocks, HTML tags, unescapes entities, and collapses excessive whitespace.
|
|
88
|
+
*
|
|
89
|
+
* @param {string} html Raw HTML email string
|
|
90
|
+
* @returns {string} Clean plain-text message
|
|
91
|
+
*/
|
|
92
|
+
export function htmlToText(html) {
|
|
93
|
+
if (!html || typeof html !== 'string') return '';
|
|
94
|
+
|
|
95
|
+
// Use fast Rust WASM HTML-to-text if engine is loaded
|
|
96
|
+
try {
|
|
97
|
+
const exp = getExports();
|
|
98
|
+
if (exp && typeof exp.rover_html_to_text === 'function') {
|
|
99
|
+
const input = writeStringToMemory(exp, memory, html);
|
|
100
|
+
const resPtr = exp.rover_html_to_text(input.ptr, input.len);
|
|
101
|
+
const text = readStringFromMemory(exp, memory, resPtr);
|
|
102
|
+
exp.rover_dealloc(input.ptr, input.len);
|
|
103
|
+
return text;
|
|
104
|
+
}
|
|
105
|
+
} catch (_) { }
|
|
106
|
+
|
|
107
|
+
// JavaScript fallback
|
|
108
|
+
return html
|
|
109
|
+
.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, ' ')
|
|
110
|
+
.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, ' ')
|
|
111
|
+
.replace(/<head[^>]*>[\s\S]*?<\/head>/gi, ' ')
|
|
112
|
+
.replace(/<\/(p|div|tr|h[1-6]|li|blockquote)>/gi, '\n')
|
|
113
|
+
.replace(/<(br|hr)\s*\/?>/gi, '\n')
|
|
114
|
+
.replace(/<[^>]+>/g, ' ')
|
|
115
|
+
.replace(/ /gi, ' ')
|
|
116
|
+
.replace(/&/gi, '&')
|
|
117
|
+
.replace(/</gi, '<')
|
|
118
|
+
.replace(/>/gi, '>')
|
|
119
|
+
.replace(/"/gi, '"')
|
|
120
|
+
.replace(/'/gi, "'")
|
|
121
|
+
.replace(/'/gi, "'")
|
|
122
|
+
.replace(/[ \t]+/g, ' ')
|
|
123
|
+
.replace(/\r?\n\s*\r?\n+/g, '\n\n')
|
|
124
|
+
.trim();
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/**
|
|
128
|
+
* Extract clean, readable normal message text from an email object or text.
|
|
129
|
+
* Handles massive HTML emails, raw multipart text bodies, and synthetic email formats.
|
|
130
|
+
*
|
|
131
|
+
* @param {object|string} email Email record or body string
|
|
132
|
+
* @returns {string} Clean message text
|
|
133
|
+
*/
|
|
134
|
+
export function cleanEmailBody(email) {
|
|
135
|
+
if (!email) return '';
|
|
136
|
+
if (typeof email === 'string') {
|
|
137
|
+
if (/<[a-z][\s\S]*>/i.test(email)) {
|
|
138
|
+
return htmlToText(email);
|
|
139
|
+
}
|
|
140
|
+
return email.replace(/\r\n/g, '\n').trim();
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
// 1. Check textBody / body / content
|
|
144
|
+
const textCandidate = email.textBody || email.body || email.content || '';
|
|
145
|
+
if (typeof textCandidate === 'string' && textCandidate.trim().length > 0) {
|
|
146
|
+
if (/<[a-z][\s\S]*>/i.test(textCandidate)) {
|
|
147
|
+
return htmlToText(textCandidate);
|
|
148
|
+
}
|
|
149
|
+
return textCandidate.replace(/\r\n/g, '\n').trim();
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
// 2. Fallback to htmlBody if textBody is empty (common in marketing / newsletters)
|
|
153
|
+
if (email.htmlBody && typeof email.htmlBody === 'string') {
|
|
154
|
+
return htmlToText(email.htmlBody);
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
return '';
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
/**
|
|
161
|
+
* Normalize an email of any format (Relay Mail, RFC822-style, or synthetic)
|
|
162
|
+
* into a standardized structured object ready for processing and display.
|
|
163
|
+
*
|
|
164
|
+
* @param {object} email Raw email object
|
|
165
|
+
* @returns {object} Normalized email object
|
|
166
|
+
*/
|
|
167
|
+
export function normalizeEmail(email) {
|
|
168
|
+
if (!email || typeof email !== 'object') {
|
|
169
|
+
throw new TypeError('Expected an email object');
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
let sender = 'unknown@example.com';
|
|
173
|
+
let senderName = '';
|
|
174
|
+
|
|
175
|
+
if (email.from) {
|
|
176
|
+
if (Array.isArray(email.from) && email.from.length > 0) {
|
|
177
|
+
sender = email.from[0].email || sender;
|
|
178
|
+
senderName = email.from[0].name || '';
|
|
179
|
+
} else if (typeof email.from === 'object') {
|
|
180
|
+
sender = email.from.email || sender;
|
|
181
|
+
senderName = email.from.name || '';
|
|
182
|
+
} else if (typeof email.from === 'string') {
|
|
183
|
+
const match = email.from.match(/(.*?)\s*<([^>]+)>/);
|
|
184
|
+
if (match) {
|
|
185
|
+
senderName = match[1].trim();
|
|
186
|
+
sender = match[2].trim();
|
|
187
|
+
} else {
|
|
188
|
+
sender = email.from.trim();
|
|
189
|
+
senderName = '';
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
} else {
|
|
193
|
+
if (email.sender) sender = email.sender;
|
|
194
|
+
if (email.sender_name) senderName = email.sender_name;
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
const subject = (email.subject || '').replace(/\r?\n/g, ' ').trim();
|
|
198
|
+
const body = cleanEmailBody(email);
|
|
199
|
+
const receivedAt = email.date || email.received_at || new Date().toISOString();
|
|
200
|
+
const id = email.id || `email_${Date.now()}`;
|
|
201
|
+
|
|
202
|
+
return {
|
|
203
|
+
id,
|
|
204
|
+
sender,
|
|
205
|
+
senderName,
|
|
206
|
+
subject,
|
|
207
|
+
body,
|
|
208
|
+
receivedAt,
|
|
209
|
+
isHtml: Boolean(!email.textBody && email.htmlBody),
|
|
210
|
+
};
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
/**
|
|
214
|
+
* Generate a concise snippet/summary from an email body for inbox listings.
|
|
215
|
+
*
|
|
216
|
+
* @param {object|string} email Email record or text
|
|
217
|
+
* @param {number} [maxLength=100] Maximum character length
|
|
218
|
+
* @returns {string} Truncated message summary
|
|
219
|
+
*/
|
|
220
|
+
export function extractSummary(email, maxLength = 100) {
|
|
221
|
+
const text = typeof email === 'string' ? email : cleanEmailBody(email);
|
|
222
|
+
const clean = text.replace(/\s+/g, ' ').trim();
|
|
223
|
+
if (clean.length <= maxLength) return clean;
|
|
224
|
+
return clean.slice(0, maxLength - 3).trim() + '...';
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
/**
|
|
228
|
+
* Rover Intelligence Index
|
|
229
|
+
* Organizes emails into connected purchase, project, and activity timelines.
|
|
230
|
+
*/
|
|
231
|
+
export const RoverIndex = {
|
|
232
|
+
/**
|
|
233
|
+
* Group processed emails into connected timelines using their deterministic timeline keys.
|
|
234
|
+
* @param {Array<object>} processedEmails
|
|
235
|
+
* @returns {{ timelines: Record<string, object>, unlinked: Array<object> }}
|
|
236
|
+
*/
|
|
237
|
+
buildTimelines(processedEmails) {
|
|
238
|
+
const timelines = {};
|
|
239
|
+
const unlinked = [];
|
|
240
|
+
|
|
241
|
+
for (const email of processedEmails) {
|
|
242
|
+
const key = email.timeline_key || email.timelineKey;
|
|
243
|
+
if (key) {
|
|
244
|
+
if (!timelines[key]) {
|
|
245
|
+
timelines[key] = {
|
|
246
|
+
timelineKey: key,
|
|
247
|
+
primaryCategory: email.primary_category,
|
|
248
|
+
events: [],
|
|
249
|
+
};
|
|
250
|
+
}
|
|
251
|
+
timelines[key].events.push(email);
|
|
252
|
+
} else {
|
|
253
|
+
unlinked.push(email);
|
|
254
|
+
}
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
return { timelines, unlinked };
|
|
258
|
+
},
|
|
259
|
+
};
|
|
260
|
+
|
|
261
|
+
export const RelayRover = {
|
|
262
|
+
/**
|
|
263
|
+
* Explicitly initialize the WASM engine with a binary buffer (optional).
|
|
264
|
+
*/
|
|
265
|
+
init,
|
|
266
|
+
|
|
267
|
+
/**
|
|
268
|
+
* Fast category detection for any arbitrary email subject and body.
|
|
269
|
+
* @param {string} subject
|
|
270
|
+
* @param {string} body
|
|
271
|
+
* @returns {string} Category name (e.g. 'Payment', 'OTP', 'Jobs', 'Travel', etc.)
|
|
272
|
+
*/
|
|
273
|
+
classify(subject, body) {
|
|
274
|
+
const exp = getExports();
|
|
275
|
+
const sub = writeStringToMemory(exp, memory, subject);
|
|
276
|
+
const bod = writeStringToMemory(exp, memory, body);
|
|
277
|
+
const resPtr = exp.rover_classify(sub.ptr, sub.len, bod.ptr, bod.len);
|
|
278
|
+
const category = readStringFromMemory(exp, memory, resPtr);
|
|
279
|
+
exp.rover_dealloc(sub.ptr, sub.len);
|
|
280
|
+
exp.rover_dealloc(bod.ptr, bod.len);
|
|
281
|
+
return category;
|
|
282
|
+
},
|
|
283
|
+
|
|
284
|
+
/**
|
|
285
|
+
* Generate concise contextual preview line (< 100 characters).
|
|
286
|
+
* @param {string} subject
|
|
287
|
+
* @param {string} body
|
|
288
|
+
* @returns {string} Preview text
|
|
289
|
+
*/
|
|
290
|
+
generatePreview(subject, body) {
|
|
291
|
+
const exp = getExports();
|
|
292
|
+
const sub = writeStringToMemory(exp, memory, subject);
|
|
293
|
+
const bod = writeStringToMemory(exp, memory, body);
|
|
294
|
+
const resPtr = exp.rover_preview(sub.ptr, sub.len, bod.ptr, bod.len);
|
|
295
|
+
const preview = readStringFromMemory(exp, memory, resPtr);
|
|
296
|
+
exp.rover_dealloc(sub.ptr, sub.len);
|
|
297
|
+
exp.rover_dealloc(bod.ptr, bod.len);
|
|
298
|
+
return preview;
|
|
299
|
+
},
|
|
300
|
+
|
|
301
|
+
/**
|
|
302
|
+
* Process email with full category detection, typed extraction, and preview generation.
|
|
303
|
+
* @param {string} subject
|
|
304
|
+
* @param {string} body
|
|
305
|
+
* @returns {object} ProcessedEmail result
|
|
306
|
+
*/
|
|
307
|
+
processEmail(subject, body) {
|
|
308
|
+
const exp = getExports();
|
|
309
|
+
const sub = writeStringToMemory(exp, memory, subject);
|
|
310
|
+
const bod = writeStringToMemory(exp, memory, body);
|
|
311
|
+
const resPtr = exp.rover_process_email(sub.ptr, sub.len, bod.ptr, bod.len);
|
|
312
|
+
const jsonStr = readStringFromMemory(exp, memory, resPtr);
|
|
313
|
+
exp.rover_dealloc(sub.ptr, sub.len);
|
|
314
|
+
exp.rover_dealloc(bod.ptr, bod.len);
|
|
315
|
+
return JSON.parse(jsonStr);
|
|
316
|
+
},
|
|
317
|
+
|
|
318
|
+
/**
|
|
319
|
+
* Process a single email from any email object (Relay Mail, HTML, or synthetic) or string.
|
|
320
|
+
* Automatically normalizes headers, cleans HTML if present, and attaches cleanBody.
|
|
321
|
+
*
|
|
322
|
+
* @param {object|string} input Email object or text
|
|
323
|
+
* @returns {object} ProcessedEmail result with cleanBody
|
|
324
|
+
*/
|
|
325
|
+
process(input) {
|
|
326
|
+
if (typeof input === 'string') {
|
|
327
|
+
const clean = cleanEmailBody(input);
|
|
328
|
+
const res = this.processEmail('', clean);
|
|
329
|
+
return { ...res, cleanBody: clean };
|
|
330
|
+
}
|
|
331
|
+
if (input && typeof input === 'object') {
|
|
332
|
+
const normalized = normalizeEmail(input);
|
|
333
|
+
const exp = getExports();
|
|
334
|
+
let res;
|
|
335
|
+
if (exp && typeof exp.rover_process_email_json === 'function') {
|
|
336
|
+
const jsonStr = JSON.stringify(normalized);
|
|
337
|
+
const inMem = writeStringToMemory(exp, memory, jsonStr);
|
|
338
|
+
const resPtr = exp.rover_process_email_json(inMem.ptr, inMem.len);
|
|
339
|
+
const outStr = readStringFromMemory(exp, memory, resPtr);
|
|
340
|
+
exp.rover_dealloc(inMem.ptr, inMem.len);
|
|
341
|
+
res = JSON.parse(outStr);
|
|
342
|
+
} else {
|
|
343
|
+
res = this.processEmail(normalized.subject, normalized.body);
|
|
344
|
+
}
|
|
345
|
+
return {
|
|
346
|
+
...res,
|
|
347
|
+
id: normalized.id,
|
|
348
|
+
cleanBody: normalized.body,
|
|
349
|
+
sender: normalized.sender,
|
|
350
|
+
senderName: normalized.senderName,
|
|
351
|
+
};
|
|
352
|
+
}
|
|
353
|
+
throw new TypeError('Expected email object or string');
|
|
354
|
+
},
|
|
355
|
+
|
|
356
|
+
/**
|
|
357
|
+
* Process multiple emails in a single in-memory WebAssembly engine call.
|
|
358
|
+
* Accepts an array of email objects (including raw Relay Mail with htmlBody) or a serialized JSON string.
|
|
359
|
+
*
|
|
360
|
+
* @param {Array<object>|string} emails Array of email records
|
|
361
|
+
* @returns {Array<object>} Array of ProcessedEmail results with cleanBody
|
|
362
|
+
*/
|
|
363
|
+
processBatch(emails) {
|
|
364
|
+
const exp = getExports();
|
|
365
|
+
const emailsArray = typeof emails === 'string' ? JSON.parse(emails) : emails;
|
|
366
|
+
|
|
367
|
+
const normalizedArray = emailsArray.map(m => {
|
|
368
|
+
if (typeof m === 'object' && m !== null) {
|
|
369
|
+
return normalizeEmail(m);
|
|
370
|
+
}
|
|
371
|
+
return m;
|
|
372
|
+
});
|
|
373
|
+
|
|
374
|
+
const jsonString = JSON.stringify(normalizedArray);
|
|
375
|
+
const input = writeStringToMemory(exp, memory, jsonString);
|
|
376
|
+
const resPtr = exp.rover_process_batch_json(input.ptr, input.len);
|
|
377
|
+
const resultsJson = readStringFromMemory(exp, memory, resPtr);
|
|
378
|
+
exp.rover_dealloc(input.ptr, input.len);
|
|
379
|
+
|
|
380
|
+
const parsed = JSON.parse(resultsJson);
|
|
381
|
+
if (Array.isArray(parsed)) {
|
|
382
|
+
return parsed.map((item, idx) => ({
|
|
383
|
+
...item,
|
|
384
|
+
cleanBody: normalizedArray[idx]?.body || '',
|
|
385
|
+
}));
|
|
386
|
+
}
|
|
387
|
+
return parsed;
|
|
388
|
+
},
|
|
389
|
+
|
|
390
|
+
/**
|
|
391
|
+
* Alias for processBatch to process an array of JSON email records.
|
|
392
|
+
* @param {Array<object>|string} emails
|
|
393
|
+
* @returns {Array<object>}
|
|
394
|
+
*/
|
|
395
|
+
processEmailsJson(emails) {
|
|
396
|
+
return this.processBatch(emails);
|
|
397
|
+
},
|
|
398
|
+
|
|
399
|
+
/**
|
|
400
|
+
* Convert HTML email content to clean, readable plain text.
|
|
401
|
+
*/
|
|
402
|
+
htmlToText,
|
|
403
|
+
|
|
404
|
+
/**
|
|
405
|
+
* Extract clean, readable normal message text from an email object or text.
|
|
406
|
+
*/
|
|
407
|
+
cleanEmailBody,
|
|
408
|
+
|
|
409
|
+
/**
|
|
410
|
+
* Normalize an email of any format into a standardized structured object.
|
|
411
|
+
*/
|
|
412
|
+
normalizeEmail,
|
|
413
|
+
|
|
414
|
+
/**
|
|
415
|
+
* Generate a concise summary snippet from an email body.
|
|
416
|
+
*/
|
|
417
|
+
extractSummary,
|
|
418
|
+
|
|
419
|
+
/**
|
|
420
|
+
* Rover Intelligence Index timeline grouping engine.
|
|
421
|
+
*/
|
|
422
|
+
index: RoverIndex,
|
|
423
|
+
};
|
|
424
|
+
|
|
425
|
+
export default RelayRover;
|