@dronedeploy/rocos-js-sdk 3.0.1-alpha.9 → 3.0.2

package/esm/helpers/kscript/nodes/expressions/ObjectExpression.js

@@ -0,0 +1,53 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class ObjectExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'ObjectExpression');
+    }
+    run() {
+        const object = {};
+        for (const property of this.node.properties) {
+            if (property.type === 'SpreadElement') {
+                this.spreadProperty(property, object);
+                continue;
+            }
+            this.addProperty(property, object);
+        }
+        return object;
+    }
+    addProperty(property, object) {
+        if (property.kind !== 'init')
+            throw new Error('Only init properties are supported');
+        const key = this.getKey(property);
+        object[key] = construct(property.value, this.context).run();
+    }
+    spreadProperty(property, object) {
+        const value = construct(property.argument, this.context).run();
+        if (!(typeof value === 'object' && value !== null)) {
+            throw new Error('Spread argument must be an object');
+        }
+        Object.assign(object, value);
+    }
+    getKey(property) {
+        let key;
+        if (property.computed) {
+            key = construct(property.key, this.context).run();
+        }
+        else {
+            key = this.getStaticKey(property.key);
+        }
+        if (key === null || key === undefined)
+            throw new Error('Key cannot be null or undefined');
+        if (typeof key !== 'string' && typeof key !== 'number' && typeof key !== 'symbol') {
+            throw new Error(`Unsupported key type: ${typeof key}`);
+        }
+        return key;
+    }
+    getStaticKey(key) {
+        if (key.type === 'Identifier')
+            return key.name;
+        if (key.type === 'Literal')
+            return key.value;
+        throw new Error('Only identifier and literal keys are supported');
+    }
+}

package/esm/helpers/kscript/nodes/expressions/UnaryExpression.d.ts

@@ -0,0 +1,12 @@
+import { AnyNode, UnaryExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/** A unary expression is an expression that consists of a single operand and an operator
+ *
+ * e.g. `+1`, `-2`, `!true`, `typeof x`
+ */
+export default class UnaryExpressionNode extends Node<UnaryExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private arithmetic;
+}

package/esm/helpers/kscript/nodes/expressions/UnaryExpression.js

@@ -0,0 +1,38 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+/** A unary expression is an expression that consists of a single operand and an operator
+ *
+ * e.g. `+1`, `-2`, `!true`, `typeof x`
+ */
+export default class UnaryExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'UnaryExpression');
+    }
+    run() {
+        const argument = construct(this.node.argument, this.context).run();
+        switch (this.node.operator) {
+            case '+':
+            case '-':
+                return this.arithmetic(this.node.operator, argument);
+            case '!':
+                return !argument;
+            case 'typeof':
+                return typeof argument;
+            default:
+                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+    }
+    arithmetic(operator, argument) {
+        if (typeof argument !== 'number') {
+            throw new Error('Unary arithmetic operators are only supported for numbers');
+        }
+        switch (operator) {
+            case '+':
+                return +argument;
+            case '-':
+                return -argument;
+            default:
+                throw new Error(`Unsupported operator: ${operator}`);
+        }
+    }
+}

package/esm/helpers/kscript/nodes/expressions/index.d.ts

@@ -0,0 +1,11 @@
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as ArrayExpression } from './ArrayExpression';
+export { default as ObjectExpression } from './ObjectExpression';
+export { default as BinaryExpression } from './BinaryExpression';
+export { default as UnaryExpression } from './UnaryExpression';
+export { default as LogicalExpression } from './LogicalExpression';
+export { default as ConditionalExpression } from './ConditionalExpression';
+export { default as CallExpression } from './CallExpression';
+export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
+export { default as MemberExpression } from './MemberExpression';
+export { default as ChainExpression } from './ChainExpression';

package/esm/helpers/kscript/nodes/expressions/index.js

@@ -0,0 +1,11 @@
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as ArrayExpression } from './ArrayExpression';
+export { default as ObjectExpression } from './ObjectExpression';
+export { default as BinaryExpression } from './BinaryExpression';
+export { default as UnaryExpression } from './UnaryExpression';
+export { default as LogicalExpression } from './LogicalExpression';
+export { default as ConditionalExpression } from './ConditionalExpression';
+export { default as CallExpression } from './CallExpression';
+export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
+export { default as MemberExpression } from './MemberExpression';
+export { default as ChainExpression } from './ChainExpression';

package/esm/helpers/kscript/nodes/index.d.ts

@@ -0,0 +1,4 @@
+import { NodeType, default as nodes } from './nodeTypes';
+import Context from '../Context';
+import Node from './Node';
+export { type Node, type NodeType, nodes, Context };

package/esm/helpers/kscript/nodes/index.js

@@ -0,0 +1,3 @@
+import { default as nodes } from './nodeTypes';
+import Context from '../Context';
+export { nodes, Context };

package/esm/helpers/kscript/nodes/nodeTypes.d.ts

@@ -0,0 +1,33 @@
+import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { AnyNode } from 'acorn';
+import type Context from '../Context';
+import Identifier from './Identifier';
+import Literal from './Literal';
+import Node from './Node';
+import Program from './Program';
+import TemplateLiteral from './TemplateLiteral';
+type NodeConstructor = {
+    new (node: AnyNode, scope: Context): Node<AnyNode>;
+};
+export type NodeMap = Map<AnyNode['type'], NodeConstructor>;
+declare const nodes: {
+    readonly Program: typeof Program;
+    readonly Literal: typeof Literal;
+    readonly ExpressionStatement: typeof ExpressionStatement;
+    readonly ArrayExpression: typeof ArrayExpression;
+    readonly ObjectExpression: typeof ObjectExpression;
+    readonly Identifier: typeof Identifier;
+    readonly BinaryExpression: typeof BinaryExpression;
+    readonly UnaryExpression: typeof UnaryExpression;
+    readonly LogicalExpression: typeof LogicalExpression;
+    readonly ConditionalExpression: typeof ConditionalExpression;
+    readonly IfStatement: typeof ConditionalExpression;
+    readonly TemplateLiteral: typeof TemplateLiteral;
+    readonly ArrowFunctionExpression: typeof ArrowFunctionExpression;
+    readonly CallExpression: typeof CallExpression;
+    readonly MemberExpression: typeof MemberExpression;
+    readonly ChainExpression: typeof ChainExpression;
+};
+export type NodeType = keyof typeof nodes;
+declare const _default: NodeMap;
+export default _default;

package/esm/helpers/kscript/nodes/nodeTypes.js

@@ -0,0 +1,24 @@
+import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression, } from './expressions';
+import Identifier from './Identifier';
+import Literal from './Literal';
+import Program from './Program';
+import TemplateLiteral from './TemplateLiteral';
+const nodes = {
+    Program,
+    Literal,
+    ExpressionStatement,
+    ArrayExpression,
+    ObjectExpression,
+    Identifier,
+    BinaryExpression,
+    UnaryExpression,
+    LogicalExpression,
+    ConditionalExpression,
+    IfStatement: ConditionalExpression,
+    TemplateLiteral,
+    ArrowFunctionExpression,
+    CallExpression,
+    MemberExpression,
+    ChainExpression,
+};
+export default new Map(Object.entries(nodes));

package/esm/helpers/kscript/utils.d.ts

@@ -0,0 +1,4 @@
+import { Node } from './nodes';
+import { AnyNode } from 'acorn';
+import Context from './Context';
+export declare function construct(node: AnyNode, context: Context): Node<AnyNode>;

package/esm/helpers/kscript/utils.js

@@ -0,0 +1,11 @@
+import { nodes } from './nodes';
+export function construct(node, context) {
+    if (!context.isNodeAllowed(node.type)) {
+        throw new Error(`Blacklisted Operation: ${node.type}`);
+    }
+    const nodeClass = nodes.get(node.type);
+    if (!nodeClass) {
+        throw new Error(`Unknown node type: ${node.type}`);
+    }
+    return Reflect.construct(nodeClass, [node, context]);
+}

package/esm/helpers/websandbox/connection.d.ts

@@ -39,6 +39,8 @@ export default class Connection<Local extends APIDeclaration<Local>, Remote exte
      * @param args - arguments to pass to remote method
      */
     callRemoteMethod<Method extends keyof Remote>(name: Method, ...args: Parameters<Remote[Method]>): Promise<ReturnType<Remote[Method]>>;
+    /** Log a message if debug mode is enabled */
+    log(...args: unknown[]): void;
     private onMessageListener;
     private callLocalMethod;
     /** Respond to remote call
@@ -62,6 +64,5 @@ export default class Connection<Local extends APIDeclaration<Local>, Remote exte
      */
     private popCallback;
     private postMessage;
-    private log;
 }
 export {};

package/esm/helpers/websandbox/connection.js

@@ -43,6 +43,12 @@ export default class Connection {
             });
         });
     }
+    /** Log a message if debug mode is enabled */
+    log(...args) {
+        if (this.options.debugMode) {
+            console.debug(`[${this.name}]`, ...args);
+        }
+    }
     onMessageListener(e) {
         this.log('Received message', e);
         const { data } = e;
@@ -125,9 +131,4 @@ export default class Connection {
         this.log('sending message', { data, targetOrigin });
         this.postMessageInternal(data, targetOrigin);
     }
-    log(...args) {
-        if (this.options.debugMode) {
-            console.debug(`[${this.name}]`, ...args);
-        }
-    }
 }

package/esm/helpers/websandbox/frame/frame.js

@@ -12,7 +12,10 @@ class Frame {
             debugMode: isDebugMode,
         });
         void this.connection.callRemoteMethod('iframeInitialised');
-        this.workerManager = new WorkerManager();
+        // use roughly half the number of logical cores available clamped between 1 and 6
+        const workers = Math.min(Math.max(Math.ceil(navigator.hardwareConcurrency / 2), 1), 6);
+        this.connection.log(`Creating ${workers} workers`);
+        this.workerManager = new WorkerManager(workers);
     }
     async runCode(task) {
         return this.workerManager.execute(task);

package/esm/helpers/websandbox/frame/frame.source.js

@@ -1,5 +1,5 @@
 // Auto-generated file
 /* eslint-disable */
 import __WORKER_SOURCE__ from './worker/worker.source';
-const source = `(()=>{"use strict";var e={880:(e,t)=>{var s;Object.defineProperty(t,"__esModule",{value:!0}),function(e){e.RESPONSE="response",e.MESSAGE="message"}(s||(s={}));const r={allowedSenderOrigin:void 0,debugMode:!1};t.default=class{constructor(e,t,s,i,o={}){this.callbacks=new Map,this.serviceMethods=new Map,this.name=e,this.options={...r,...o},this.log("Created connection w/ allowedOrigin:",this.options.allowedSenderOrigin),this.serviceMethods=new Map(Object.entries(s));const[n]=crypto.getRandomValues(new Uint32Array(1));this.incrementalID=n,this.postMessageInternal=t,i((e=>this.onMessageListener(e)))}callRemoteMethod(e,...t){return this.log("Calling Remote Method",{name:e,args:t}),new Promise(((r,i)=>{const o=this.registerCallback(r,i);this.postMessage({callId:o,type:s.MESSAGE,methodName:e,arguments:t})}))}onMessageListener(e){this.log("Received message",e);const{data:t}=e,{allowedSenderOrigin:r}=this.options;switch(r&&e.origin!==r&&console.warn(\`Received message from invalid origin: \${e.origin}\`),t.type){case s.RESPONSE:return void this.popCallback(t.callId,t.success,t.result);case s.MESSAGE:this.callLocalMethod(t.methodName,t.arguments).then((e=>this.responseOtherSide(t.callId,e))).catch((e=>this.responseOtherSide(t.callId,e,!1)))}}async callLocalMethod(e,t){this.log("calling local method",e,t);const s=this.serviceMethods.get(e);if(!s)throw new Error(\`service method \${e} not found\`);return s(...t)}responseOtherSide(e,t,r=!0){this.log("responding to remote call",{id:e,result:t,success:r});const i=t=>{this.postMessage({callId:e,type:s.RESPONSE,success:r,result:t})};try{i(t)}catch(e){e instanceof DOMException&&i(JSON.parse(JSON.stringify(t)))}}registerCallback(e,t){const s=(++this.incrementalID).toString();return this.log("registering callback for id",s),this.callbacks.set(s,{success:e,failure:t}),s}popCallback(e,t,s){this.log("calling callback for id",e,{success:t,result:s});const r=this.callbacks.get(e);t?r?.success(s):r?.failure(s),this.callbacks.delete(e)}postMessage(e,t="*"){this.log("sending message",{data:e,targetOrigin:t}),this.postMessageInternal(e,t)}log(...e){this.options.debugMode&&console.debug(\`[\${this.name}]\`,...e)}}},306:function(e,t,s){var r=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0});const i=r(s(880)),o=r(s(54)),n=new class{constructor(){const e=!!window?.debugMode;this.connection=new i.default("FRAME",window.parent.postMessage.bind(window.parent),{startTask:this.runCode.bind(this)},(e=>{window.addEventListener("message",e)}),{debugMode:e}),this.connection.callRemoteMethod("iframeInitialised"),this.workerManager=new o.default}async runCode(e){return this.workerManager.execute(e)}};t.default=n},54:function(e,t,s){var r=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0});const i=r(s(420));t.default=i.default},420:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.default=class{constructor(){this.messageListeners=new Map,this.worker=this.createWorker()}async execute(e){const t={...e,contextVariable:e.contextVariable??"ctx"},s=this.runTask(t),r=new Promise(((t,s)=>{const r=AbortSignal.timeout(e.timeout);r.addEventListener("abort",(()=>{s(r.reason)}))}));return Promise.race([s,r]).catch((e=>{throw"TimeoutError"===e.name&&this.terminate(),e})).finally((()=>{this.removeMessageListener(e.id)}))}terminate(){for(const e of this.messageListeners.values())this.worker.removeEventListener("message",e);this.worker.terminate(),this.worker=this.createWorker()}runTask(e){return new Promise(((t,s)=>{const r=r=>{const{data:i}=r;i.id===e.id&&(i.success?t(i.result):s(i.result))};this.messageListeners.set(e.id,r),this.worker.addEventListener("message",r),this.worker.postMessage(e)}))}createWorker(){const e=URL.createObjectURL(new Blob(["${__WORKER_SOURCE__.replace(/(['`"$])/g, '\\$1')}"],{type:"application/javascript"}));return new Worker(e)}removeMessageListener(e){const t=this.messageListeners.get(e);t&&this.worker.removeEventListener("message",t)}}}},t={};!function s(r){var i=t[r];if(void 0!==i)return i.exports;var o=t[r]={exports:{}};return e[r].call(o.exports,o,o.exports,s),o.exports}(306)})();`;
+const source = `(()=>{"use strict";var e;!function(e){e.RESPONSE="response",e.MESSAGE="message"}(e||(e={}));const s={allowedSenderOrigin:void 0,debugMode:!1};class t{constructor(e,t,r,n,o={}){this.callbacks=new Map,this.serviceMethods=new Map,this.name=e,this.options={...s,...o},this.log("Created connection w/ allowedOrigin:",this.options.allowedSenderOrigin),this.serviceMethods=new Map(Object.entries(r));const[i]=crypto.getRandomValues(new Uint32Array(1));this.incrementalID=i,this.postMessageInternal=t,n((e=>this.onMessageListener(e)))}callRemoteMethod(s,...t){return this.log("Calling Remote Method",{name:s,args:t}),new Promise(((r,n)=>{const o=this.registerCallback(r,n);this.postMessage({callId:o,type:e.MESSAGE,methodName:s,arguments:t})}))}log(...e){this.options.debugMode&&console.debug(\`[\${this.name}]\`,...e)}onMessageListener(s){this.log("Received message",s);const{data:t}=s,{allowedSenderOrigin:r}=this.options;switch(r&&s.origin!==r&&console.warn(\`Received message from invalid origin: \${s.origin}\`),t.type){case e.RESPONSE:return void this.popCallback(t.callId,t.success,t.result);case e.MESSAGE:this.callLocalMethod(t.methodName,t.arguments).then((e=>this.responseOtherSide(t.callId,e))).catch((e=>this.responseOtherSide(t.callId,e,!1)))}}async callLocalMethod(e,s){this.log("calling local method",e,s);const t=this.serviceMethods.get(e);if(!t)throw new Error(\`service method \${e} not found\`);return t(...s)}responseOtherSide(s,t,r=!0){this.log("responding to remote call",{id:s,result:t,success:r});const n=t=>{this.postMessage({callId:s,type:e.RESPONSE,success:r,result:t})};try{n(t)}catch(e){e instanceof DOMException&&n(JSON.parse(JSON.stringify(t)))}}registerCallback(e,s){const t=(++this.incrementalID).toString();return this.log("registering callback for id",t),this.callbacks.set(t,{success:e,failure:s}),t}popCallback(e,s,t){this.log("calling callback for id",e,{success:s,result:t});const r=this.callbacks.get(e);s?r?.success(t):r?.failure(t),this.callbacks.delete(e)}postMessage(e,s="*"){this.log("sending message",{data:e,targetOrigin:s}),this.postMessageInternal(e,s)}}new class{constructor(){const e=!!window?.debugMode;this.connection=new t("FRAME",window.parent.postMessage.bind(window.parent),{startTask:this.runCode.bind(this)},(e=>{window.addEventListener("message",e)}),{debugMode:e}),this.connection.callRemoteMethod("iframeInitialised");const s=Math.max(Math.ceil(navigator.hardwareConcurrency/2),1);this.connection.log(\`Creating \${s} workers\`),this.workerManager=new class{constructor(e=1){this.messageListeners=new Map,this.requestedWorkers=e,this.workers=Array.from({length:e},(()=>this.createWorker())),this.nextWorkerGenerator=this.nextWorker()}async execute(e){const s=this.nextWorkerGenerator.next().value,t={...e,contextVariable:e.contextVariable??"ctx"},r=this.runTask(s,t),n=new Promise(((s,t)=>{const r=AbortSignal.timeout(e.timeout);r.addEventListener("abort",(()=>{t(r.reason)}))}));return Promise.race([r,n]).catch((e=>{if("TimeoutError"===e.name)throw this.terminate(s),new DOMException("soft timeout reached","TimeoutError");throw e})).finally((()=>{this.removeMessageListener(e.id)}))}terminate(e){for(const s of this.messageListeners.values())e.removeEventListener("message",s);e.terminate(),this.rebuildWorkers()}runTask(e,s){return new Promise(((t,r)=>{const n=e=>{const{data:n}=e;n.id===s.id&&(n.success?t(n.result):r(n.result))};this.messageListeners.set(s.id,n),e.addEventListener("message",n),e.postMessage(s)}))}createWorker(){const e=URL.createObjectURL(new Blob(["${__WORKER_SOURCE__.replace(/(['`"$])/g, '\\$1')}"],{type:"application/javascript"}));return new Worker(e)}rebuildWorkers(){const e=this.requestedWorkers-this.workers.length;if(e<0)throw new Error("Cannot have less than 0 workers");if(e<=0)return;const s=Array.from({length:e},(()=>this.createWorker()));this.workers.push(...s)}*nextWorker(){let e=0;for(;;)e=(e+1)%this.workers.length,yield this.workers[e]}removeMessageListener(e){const s=this.messageListeners.get(e);s&&(this.workers.forEach((e=>e.removeEventListener("message",s))),this.messageListeners.delete(e))}}(s)}async runCode(e){return this.workerManager.execute(e)}}})();`;
 export default source;

package/esm/helpers/websandbox/frame/worker/manager.d.ts

@@ -1,11 +1,15 @@
 import { Task } from '../../types';
 export default class Manager {
-    private worker;
-    private messageListeners;
-    constructor();
+    private readonly requestedWorkers;
+    private readonly workers;
+    private nextWorkerIndex;
+    private readonly messageListeners;
+    constructor(workers?: number);
     execute(task: Task): Promise<unknown>;
-    terminate(): void;
+    private terminate;
     private runTask;
     private createWorker;
+    private rebuildWorkers;
+    private getWorker;
     private removeMessageListener;
 }

package/esm/helpers/websandbox/frame/worker/manager.js

@@ -1,16 +1,19 @@
 // this token (__WORKER_SOURCE__) is replaced by webpack with the source of the worker
 const WORKER_SOURCE = '__WORKER_SOURCE__';
 export default class Manager {
-    constructor() {
+    constructor(workers = 1) {
+        this.nextWorkerIndex = 0;
         this.messageListeners = new Map();
-        this.worker = this.createWorker();
+        this.requestedWorkers = workers;
+        this.workers = Array.from({ length: workers }, () => this.createWorker());
     }
     async execute(task) {
+        const worker = this.getWorker();
         const workerTask = {
             ...task,
             contextVariable: task.contextVariable ?? 'ctx',
         };
-        const result = this.runTask(workerTask);
+        const result = this.runTask(worker, workerTask);
         const timeout = new Promise((_, reject) => {
             const signal = AbortSignal.timeout(task.timeout);
             signal.addEventListener('abort', () => {
@@ -20,7 +23,8 @@ export default class Manager {
         return Promise.race([result, timeout])
             .catch((e) => {
             if (e.name === 'TimeoutError') {
-                this.terminate();
+                this.terminate(worker);
+                throw new DOMException('soft timeout reached', 'TimeoutError');
             }
             throw e;
         })
@@ -28,14 +32,14 @@ export default class Manager {
             this.removeMessageListener(task.id);
         });
     }
-    terminate() {
+    terminate(worker) {
         for (const listener of this.messageListeners.values()) {
-            this.worker.removeEventListener('message', listener);
+            worker.removeEventListener('message', listener);
         }
-        this.worker.terminate();
-        this.worker = this.createWorker();
+        worker.terminate();
+        this.rebuildWorkers();
     }
-    runTask(task) {
+    runTask(worker, task) {
         return new Promise((resolve, reject) => {
             const listener = (event) => {
                 const { data } = event;
@@ -49,19 +53,33 @@ export default class Manager {
                 }
             };
             this.messageListeners.set(task.id, listener);
-            this.worker.addEventListener('message', listener);
-            this.worker.postMessage(task);
+            worker.addEventListener('message', listener);
+            worker.postMessage(task);
         });
     }
     createWorker() {
         const blob = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: 'application/javascript' }));
         return new Worker(blob);
     }
+    rebuildWorkers() {
+        const needed = this.requestedWorkers - this.workers.length;
+        if (needed < 0)
+            throw new Error('Cannot have less than 0 workers');
+        if (needed <= 0)
+            return;
+        const newWorkers = Array.from({ length: needed }, () => this.createWorker());
+        this.workers.push(...newWorkers);
+    }
+    getWorker() {
+        const worker = this.workers[this.nextWorkerIndex];
+        this.nextWorkerIndex = (this.nextWorkerIndex + 1) % this.workers.length;
+        return worker;
+    }
     removeMessageListener(id) {
         const listener = this.messageListeners.get(id);
-        if (!listener) {
+        if (!listener)
             return;
-        }
-        this.worker.removeEventListener('message', listener);
+        this.workers.forEach((worker) => worker.removeEventListener('message', listener));
+        this.messageListeners.delete(id);
     }
 }

package/esm/helpers/websandbox/frame/worker/worker.source.js

@@ -1,4 +1,4 @@
 // Auto-generated file
 /* eslint-disable */
-const source = `(()=>{"use strict";(()=>{const e=["TEMPORARY","PERSISTENT","console","self","onmessage","postMessage","global","allowed","Array","Boolean","Date","Function","Number","Object","RegExp","String","Error","EvalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","isFinite","isNaN","parseFloat","parseInt","Infinity","JSON","Math","NaN","undefined"];[...Object.getOwnPropertyNames(self),...Object.getOwnPropertyNames(self.__proto__)].forEach((r=>{e.includes(r)||Object.defineProperty(self,r,{get:()=>{throw new Error(\`Security Exception: cannot access \${r}\`)},set:()=>{throw new Error(\`Security Exception: cannot set \${r}\`)},configurable:!1})})),onmessage=e=>{let r,t=!0;try{r=Function(e.data.contextVariable,\`"use strict";return (\${e.data.code});\`)(e.data.context)}catch(e){r=e,t=!1}const o={id:e.data.id,result:r,success:t};postMessage(o)}})()})();`;
+const source = `(()=>{"use strict";const e=["TEMPORARY","PERSISTENT","console","self","onmessage","postMessage","global","allowed","Array","Boolean","Date","Function","Number","Object","RegExp","String","Error","EvalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","isFinite","isNaN","parseFloat","parseInt","Infinity","JSON","Math","NaN","undefined"];[...Object.getOwnPropertyNames(self),...Object.getOwnPropertyNames(self.__proto__)].forEach((r=>{e.includes(r)||Object.defineProperty(self,r,{get:()=>{throw new Error(\`Security Exception: cannot access \${r}\`)},set:()=>{throw new Error(\`Security Exception: cannot set \${r}\`)},configurable:!1})})),onmessage=e=>{let r,t=!0;try{r=Function(e.data.contextVariable,\`"use strict";return (\${e.data.code});\`)(e.data.context)}catch(e){r=e,t=!1}const o={id:e.data.id,result:r,success:t};postMessage(o)}})();`;
 export default source;

package/esm/helpers/websandbox/sandbox.d.ts

@@ -44,7 +44,7 @@ export default class WebSandbox {
      *
      * This will remove the iframe from the DOM and remove the message listener.
      */
-    destroy(): void;
+    destroy(reason?: unknown): void;
     private initialise;
     private validateOptions;
     private destroyAndRebuild;

package/esm/helpers/websandbox/sandbox.js

@@ -29,8 +29,8 @@ export default class WebSandbox {
         this.initialised = this.initialise();
         this.frameAbortController = new AbortController();
         if (options.abortSignal) {
-            this.promisifyAbortSignal(options.abortSignal).catch(() => {
-                void this.destroyAndRebuild(this.frame.id);
+            this.promisifyAbortSignal(options.abortSignal).catch((reason) => {
+                void this.destroyAndRebuild(this.frame.id, reason);
             });
         }
     }
@@ -45,8 +45,8 @@ export default class WebSandbox {
      *
      * This will remove the iframe from the DOM and remove the message listener.
      */
-    destroy() {
-        this.frameAbortController.abort();
+    destroy(reason) {
+        this.frameAbortController.abort(reason);
         this.frame.remove();
         this.removeMessageListener();
     }
@@ -79,11 +79,11 @@ export default class WebSandbox {
             throw new Error('maximum timeout must be less than or equal to 5000ms');
         }
     }
-    async destroyAndRebuild(frameId) {
+    async destroyAndRebuild(frameId, reason) {
         if (this.frame.id !== frameId) {
             return;
         }
-        this.destroy();
+        this.destroy(reason);
         this.frame = this.createFrame();
         this.frameAbortController = new AbortController();
         await this.initialise();
@@ -117,7 +117,7 @@ export default class WebSandbox {
         const signals = [task, timeout, frameAbortedSignal, userAbortedSignal].filter((i) => i !== null);
         return Promise.race(signals).catch(async (e) => {
             if (e.name === 'TimeoutError') {
-                await this.destroyAndRebuild(frameId);
+                await this.destroyAndRebuild(frameId, 'task timed out');
             }
             throw e;
         });

package/esm/models/IConnectedCallsign.d.ts

@@ -0,0 +1,10 @@
+export declare enum ConnectionStatus {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED"
+}
+export interface IConnectedCallsign {
+    status: ConnectionStatus;
+    details: {
+        duration: number;
+    };
+}

package/esm/models/IConnectedCallsign.js

@@ -0,0 +1,5 @@
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["CONNECTED"] = "CONNECTED";
+    ConnectionStatus["DISCONNECTED"] = "DISCONNECTED";
+})(ConnectionStatus || (ConnectionStatus = {}));

package/esm/models/RocosError.d.ts

@@ -24,6 +24,9 @@ export declare const errorCodes: {
     MAPS_SERVICE_ERROR: string;
     EVALUATOR_SERVICE_ERROR: string;
     WEBRTC_SERVICE_ERROR: string;
+    DEVICE_CREDENTIALS_SERVICE_ERROR: string;
+    TARGET_SERVICE_ERROR: string;
+    ENVIRONMENT_SERVICE_ERROR: string;
 };
 export declare class RocosError extends Error {
     code?: string;

package/esm/models/RocosError.js

@@ -24,6 +24,9 @@ export const errorCodes = {
     MAPS_SERVICE_ERROR: 'MAPS_SERVICE_ERROR',
     EVALUATOR_SERVICE_ERROR: 'EVALUATOR_SERVICE_ERROR',
     WEBRTC_SERVICE_ERROR: 'WEBRTC_SERVICE_ERROR',
+    DEVICE_CREDENTIALS_SERVICE_ERROR: 'DEVICE_CREDENTIALS_SERVICE_ERROR',
+    TARGET_SERVICE_ERROR: 'TARGET_SERVICE_ERROR',
+    ENVIRONMENT_SERVICE_ERROR: 'ENVIRONMENT_SERVICE_ERROR',
 };
 export class RocosError extends Error {
     constructor(err, code, statusCode) {

package/esm/models/ServiceEnum.d.ts

@@ -1,28 +1,31 @@
 export declare enum ServiceEnum {
+    ASSET_STORAGE = "asset_storage",
     AUTH = "auth",
-    TELEMETRY = "telemetry",
-    ROBOT = "robot",
-    EVENT = "event",
-    PROJECT = "project",
     CALLER = "caller",
     COMMAND = "command",
-    CONTROL = "control",
-    SEARCH = "search",
     CONFIG_GROUP = "config_group",
+    CONTROL = "control",
     DASHBOARD = "dashboard",
+    DEVICE_CREDENTIALS = "device_credentials",
+    ENVIRONMENT = "environment",
+    EVENT = "event",
+    EVALUATOR = "evaluator",
+    FILE_ACCESSOR = "file_accessor",
     FUNCTION = "function",
-    STREAM = "stream",
-    USER = "user",
-    TIME_SYNCER = "time_syncer",
-    WORKFLOW = "workflow",
-    ASSET_STORAGE = "asset_storage",
+    INTEGRATION = "integration",
+    MAP = "map",
+    PROJECT = "project",
     PROFILE = "profile",
-    WEBRTC_SIGNALLING = "webrtc_signalling",
-    FILE_ACCESSOR = "file_accessor",
+    ROBOT = "robot",
+    RTP_WEBRTC = "rtp_webrtc",
     SCHEDULE = "schedule",
+    SEARCH = "search",
     SPOT_PROVISIONER = "spot_provisioner",
-    INTEGRATION = "integration",
-    MAP = "map",
-    EVALUATOR = "evaluator",
-    RTP_WEBRTC = "rtp_webrtc"
+    STREAM = "stream",
+    TARGET = "target",
+    TELEMETRY = "telemetry",
+    TIME_SYNCER = "time_syncer",
+    USER = "user",
+    WEBRTC_SIGNALLING = "webrtc_signalling",
+    WORKFLOW = "workflow"
 }

package/esm/models/ServiceEnum.js

@@ -1,29 +1,32 @@
 export var ServiceEnum;
 (function (ServiceEnum) {
+    ServiceEnum["ASSET_STORAGE"] = "asset_storage";
     ServiceEnum["AUTH"] = "auth";
-    ServiceEnum["TELEMETRY"] = "telemetry";
-    ServiceEnum["ROBOT"] = "robot";
-    ServiceEnum["EVENT"] = "event";
-    ServiceEnum["PROJECT"] = "project";
     ServiceEnum["CALLER"] = "caller";
     ServiceEnum["COMMAND"] = "command";
-    ServiceEnum["CONTROL"] = "control";
-    ServiceEnum["SEARCH"] = "search";
     ServiceEnum["CONFIG_GROUP"] = "config_group";
+    ServiceEnum["CONTROL"] = "control";
     ServiceEnum["DASHBOARD"] = "dashboard";
-    ServiceEnum["FUNCTION"] = "function";
-    ServiceEnum["STREAM"] = "stream";
-    ServiceEnum["USER"] = "user";
-    ServiceEnum["TIME_SYNCER"] = "time_syncer";
-    ServiceEnum["WORKFLOW"] = "workflow";
-    ServiceEnum["ASSET_STORAGE"] = "asset_storage";
-    ServiceEnum["PROFILE"] = "profile";
-    ServiceEnum["WEBRTC_SIGNALLING"] = "webrtc_signalling";
+    ServiceEnum["DEVICE_CREDENTIALS"] = "device_credentials";
+    ServiceEnum["ENVIRONMENT"] = "environment";
+    ServiceEnum["EVENT"] = "event";
+    ServiceEnum["EVALUATOR"] = "evaluator";
     ServiceEnum["FILE_ACCESSOR"] = "file_accessor";
-    ServiceEnum["SCHEDULE"] = "schedule";
-    ServiceEnum["SPOT_PROVISIONER"] = "spot_provisioner";
+    ServiceEnum["FUNCTION"] = "function";
     ServiceEnum["INTEGRATION"] = "integration";
     ServiceEnum["MAP"] = "map";
-    ServiceEnum["EVALUATOR"] = "evaluator";
+    ServiceEnum["PROJECT"] = "project";
+    ServiceEnum["PROFILE"] = "profile";
+    ServiceEnum["ROBOT"] = "robot";
     ServiceEnum["RTP_WEBRTC"] = "rtp_webrtc";
+    ServiceEnum["SCHEDULE"] = "schedule";
+    ServiceEnum["SEARCH"] = "search";
+    ServiceEnum["SPOT_PROVISIONER"] = "spot_provisioner";
+    ServiceEnum["STREAM"] = "stream";
+    ServiceEnum["TARGET"] = "target";
+    ServiceEnum["TELEMETRY"] = "telemetry";
+    ServiceEnum["TIME_SYNCER"] = "time_syncer";
+    ServiceEnum["USER"] = "user";
+    ServiceEnum["WEBRTC_SIGNALLING"] = "webrtc_signalling";
+    ServiceEnum["WORKFLOW"] = "workflow";
 })(ServiceEnum || (ServiceEnum = {}));

package/esm/models/TelemetryStatus.d.ts

@@ -0,0 +1,12 @@
+export declare enum TelemetryMonitorStatus {
+    UNKNOWN = "unknown",
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected",
+    ERROR = "error"
+}
+export declare enum CallsignStatus {
+    UNKNOWN = "unknown",
+    ONLINE = "online",
+    OFFLINE = "offline",
+    ERROR = "error"
+}