clever-queue 0.1.1 → 0.2.0

package/package.json

@@ -1,55 +1,65 @@
-{
-  "name": "clever-queue",
-  "version": "0.1.1",
-  "description": "Queuing system for promises that handle concurring, throttling, weighting and prioritizing in a clever fashion.",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "npx tsc -p src/ --declaration",
-    "build:watch": "npx tsc -p src/ -w",
-    "prestart": "npx npm run build",
-    "start": "node dist/index.js",
-    "debug": "node --nolazy --inspect-brk=9229 dist/index.js",
-    "test": "node --test ./test/**/*.mjs",
-    "test:unit:watch": "node --test --watch ./test/units/*.mjs"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://gitlab.com/job-so/clever-queue.git"
-  },
-  "keywords": [
-    "queue",
-    "clever",
-    "concurrency",
-    "throttling",
-    "priority",
-    "weight",
-    "promise"
-  ],
-  "author": "Olivier GROSJEANNE",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://gitlab.com/job-so/clever-queue/issues"
-  },
-  "homepage": "https://gitlab.com/job-so/clever-queue#readme",
-  "devDependencies": {
-    "@eslint/eslintrc": "^3.1",
-    "@eslint/js": "^9.8",
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/sdk-metrics": "^1.26",
-    "@opentelemetry/sdk-node": "^0.53",
-    "@opentelemetry/sdk-trace-node": "^1.26",
-    "@types/eslint__js": "^8.42",
-    "@types/node": "^22.1",
-    "eslint": "^9.8",
-    "eslint-config-prettier": "^9.1",
-    "eslint-plugin-node": "^11.1",
-    "eslint-plugin-prettier": "^5.1",
-    "eslint-plugin-promise": "^6.4",
-    "eslint-plugin-security": "^3.0",
-    "eslint-plugin-unicorn": "^54.0",
-    "globals": "^15.9",
-    "node": "^22.4",
-    "typescript": "^5.5",
-    "typescript-eslint": "^8.0"
-  }
-}
+{
+  "name": "clever-queue",
+  "version": "0.2.0",
+  "description": "Queuing system for promises that handle concurring, throttling, weighting and prioritizing in a clever fashion.",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npx tsc -p src/ --declaration",
+    "build:examples": "npx tsc -p examples/src/",
+    "build:watch": "npx tsc -p src/ -w",
+    "prestart": "npx npm run build",
+    "start": "node dist/index.js",
+    "debug": "node --nolazy --inspect-brk=9229 dist/index.js",
+    "test": "node --test ./test/**/*.mjs",
+    "test:junit": "node --test --test-reporter=junit --test-reporter-destination=junit.xml ./test/**/*.mjs",
+    "test:unit:watch": "node --test --watch ./test/units/*.mjs",
+    "semantic-release": "npx semantic-release"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/job-so/clever-queue.git"
+  },
+  "release": {
+    "branches": [
+      "v0"
+    ]
+  },
+  "keywords": [
+    "queue",
+    "clever",
+    "concurrency",
+    "throttling",
+    "priority",
+    "weight",
+    "promise"
+  ],
+  "author": "Olivier GROSJEANNE",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/job-so/clever-queue/issues"
+  },
+  "homepage": "https://gitlab.com/job-so/clever-queue#readme",
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.1",
+    "@eslint/js": "^9.8",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/sdk-metrics": "^1.26",
+    "@opentelemetry/sdk-node": "^0.53",
+    "@opentelemetry/sdk-trace-node": "^1.26",
+    "@types/eslint__js": "^8.42",
+    "@types/node": "^22.1",
+    "eslint": "^9.8",
+    "eslint-config-prettier": "^9.1",
+    "eslint-plugin-node": "^11.1",
+    "eslint-plugin-prettier": "^5.1",
+    "eslint-plugin-promise": "^6.4",
+    "eslint-plugin-security": "^3.0",
+    "eslint-plugin-unicorn": "^54.0",
+    "fast-xml-parser": "^5.0.9",
+    "globals": "^15.9",
+    "node": "^24.12",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.9",
+    "typescript-eslint": "^8.50"
+  }
+}

package/src/engine/index.ts

@@ -1,13 +1,13 @@
 // clever-queue
 
 import * as _ from "../helpers";
-import * as Queue from "../queue";
-import * as Runner from "../runner";
-import * as Task from "../task";
+import * as cqQueue from "../queues";
+import * as cqRunner from "../runners";
+import * as cqTask from "../tasks";
 
 type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
 
-const TICK_START = 42;
+const TICK_START = 42; // RANDOM ? ;-) value to avoid zero division
 
 import { Options, Statistics, ErrorsList } from "./interfaces";
 
@@ -19,18 +19,21 @@ const defaultOptions: Options = {
 
 class Engine {
   status: Status = "unknown";
-  readonly runners: Runner.Runner[] = [];
-  readonly queues: Queue.Queue[] = [];
+  readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+  readonly runners: cqRunner.Runner[] = [];
+  readonly queues: cqQueue.Queue[] = [];
 
   constructor(opt: Options) {
     this.status = "initialiazing";
-    const options = { ...defaultOptions, ...opt };
-    this.#checkOptionsConsistancy(options);
+    this.options = { ...defaultOptions, ...opt };
+    if (!this.options.id) this.options.id = _.Id.generate();
+    this.#checkOptionsConsistancy(this.options);
 
     // create runners
-    for (let index = 0; index < (options.bestEffortRunners ?? 0); index++) this.createRunner({ priority: Runner.Priorities.BestEffort });
-    if (options.logFunction) options.logFunction({ body: "engine has been initialized" });
-    if (options.autostart) this.start();
+    for (let index = 0; index < (this.options.bestEffortRunners ?? 0); index++) this.createRunner({ priority: cqRunner.Priorities.BestEffort });
+    if (this.options.logFunction) this.options.logFunction({ body: "engine has been initialized" });
+    if (this.options.autostart) this.start();
   }
 
   start(): void {
@@ -43,21 +46,21 @@ class Engine {
     for (const runner of this.runners) runner.stop();
   }
 
-  createQueue(options: Queue.Options): Queue.Queue {
-    const queue = new Queue.Queue({ logFunction: options.logFunction, ...options });
+  createQueue(options: cqQueue.Options = { priority: cqQueue.Priorities.Standard, weight: cqQueue.Weights.Default }): cqQueue.Queue {
+    const queue = new cqQueue.Queue({ logFunction: options.logFunction, ...options });
     this.queues.push(queue);
     this.#resetLastTick(options.priority);
     return queue;
   }
 
-  createRunner(options: Runner.Options): Runner.Runner {
-    const runner = new Runner.Runner({ logFunction: options.logFunction, ...options }, this);
+  createRunner(options: cqRunner.Options): cqRunner.Runner {
+    const runner = new cqRunner.Runner({ logFunction: options.logFunction, ...options }, this);
     this.runners.push(runner);
     return runner;
   }
 
-  createTask(function_: Task.FunctionToExecute, options: Task.Options): Task.Task {
-    return new Task.Task(function_, { logFunction: options.logFunction, ...options });
+  createTask(function_: cqTask.FunctionToExecute, options: cqTask.Options): cqTask.Task {
+    return new cqTask.Task(function_, { logFunction: options.logFunction, ...options });
   }
 
   #checkOptionsConsistancy(options: Options): void {
@@ -65,19 +68,25 @@ class Engine {
     if (!options.bestEffortRunners || options.bestEffortRunners < 1) throw new _.Errors.CQError(ErrorsList.bestEffortRunnersOptionMustBeGreaterThanZero);
   }
 
-  #getSumWeightFunction: Queue.GetSumWeightFunction = (priority: number): number => {
+  #getSumWeightFunction: cqQueue.GetSumWeightFunction = (priority: number): number => {
     let result = 0;
     for (const q of this.queues) if (q.options.priority === priority) result += q.options.weight;
     return result;
   };
 
   #resetLastTick(priority: number): void {
-    for (const q of this.queues) if (q.options.priority === priority) q.tick = TICK_START;
+    for (let i = 0; i < this.queues.length; i++) {
+      const q = this.queues[i];
+      if (q.options.priority === priority)
+        q.tick = TICK_START
+          + this.#getSumWeightFunction(priority) / q.options.weight // set tick to max weight / queue weight to favorize low weight queues
+          + i / 255; // slight increment to favorize first created queues
+    }
   }
 
-  #getNextWeightedQueue(priority: number): Queue.Queue | undefined {
+  #getNextWeightedQueue(priority: number): cqQueue.Queue | undefined {
     let minTick = Infinity;
-    let result: Queue.Queue | undefined = undefined;
+    let result: cqQueue.Queue | undefined = undefined;
     for (const q of this.queues)
       if (q.options.priority === priority && q.tick <= minTick) {
         minTick = q.tick;
@@ -91,32 +100,12 @@ class Engine {
     for (const q of this.queues) if (q.options.priority === priority) result += q.tasks.length;
     return result;
   }
-  /*
-   async getNextTask(priorityGreaterOrEqualTo: number): Promise<Task.Task> {
-    for (let priority = Queue.Priorities.Absolute; priority <= priorityGreaterOrEqualTo; priority++) {
-      // Iterate on Each PriorityLevel From Absolute to param function
-      while (this.#howMuchTasksWaitingInQueues(priority) > 0) {
-        let task: Task.Task | undefined;
-        while (!task) {
-          const nextPriorityQueue = this.#getNextQueue(priority); // Find Next Priority Queue to process
-          if (nextPriorityQueue) {
-            nextPriorityQueue.tick += this.#getSumWeightFunction(priority) / nextPriorityQueue.options.weight; // Update tick with related weight
-            if (nextPriorityQueue.tasks.length > 0) {
-              task = nextPriorityQueue.tasks.shift(); // If queue is not empty, this is our next Task to process
-              if (task) task.runner();
-              console.log(nextPriorityQueue.options.name, nextPriorityQueue.tick);
-            }
-          }
-        }
-      }
-    }
-  }
-  */
 
-  async getNextTask(priorityGreaterOrEqualTo: number): Promise<Task.Task | undefined> {
-    let task: Task.Task | undefined = undefined;
+  async getNextTask(priorityGreaterOrEqualTo: number): Promise<cqTask.Task | undefined> {
+    if (this.status !== "running") return undefined;
+    let task: cqTask.Task | undefined = undefined;
     // Iterate on Each PriorityLevel From Absolute to parameter
-    for (let priority = Queue.Priorities.Absolute; priority <= priorityGreaterOrEqualTo; priority++) {
+    for (let priority = cqQueue.Priorities.Absolute; priority >= priorityGreaterOrEqualTo; priority--) {
       // Check if there is task waiting of this priority level
       while (this.#howMuchTasksWaitingInQueues(priority) > 0) {
         // Find Next Weighted Queue of this priority level to check
@@ -138,8 +127,8 @@ class Engine {
 
   statistics(): Statistics {
     let taskCount = 0;
-    const runners: Runner.Statistics[] = [];
-    const queues: Queue.Statistics[] = [];
+    const runners: cqRunner.Statistics[] = [];
+    const queues: cqQueue.Statistics[] = [];
     for (const runner of this.runners) {
       if (runner.status == "running") taskCount += 1;
       runners.push(runner.statistics());
@@ -162,5 +151,5 @@ class Engine {
   }
 }
 
-export { Options, Statistics, ErrorsList } from "./interfaces";
+export { Options, Statistics, ErrorsList, LogFunction } from "./interfaces";
 export { Engine };

package/src/engine/interfaces.ts

@@ -1,9 +1,10 @@
 import * as _ from "../helpers";
 
-import * as Runner from "../runner/interfaces";
-import * as Queue from "../runner/interfaces";
+import * as Runner from "../runners/interfaces";
+import * as Queue from "../runners/interfaces";
 
 interface Options {
+  id?: string;
   autostart?: boolean;
   bestEffortRunners?: number;
   logFunction?: _.Logs.LogFunction;

package/src/helpers/id.ts

@@ -0,0 +1,4 @@
+function generate(): string {
+  return Math.floor(Math.random() * Date.now()).toString(16);
+}
+export { generate };

package/src/helpers/index.ts

@@ -1,3 +1,4 @@
 export * as Errors from "./errors";
 export * as Logs from "./logs";
 export * as Traces from "./traces";
+export * as Id from "./id";

package/src/index.ts

@@ -1,13 +1,13 @@
 // clever-queue
-import * as Engine from "./engine";
+import * as engine from "./engine";
 
-function createEngine(options: Engine.Options): Engine.Engine {
-  return new Engine.Engine(options);
+function createEngine(options: engine.Options = {}): engine.Engine {
+  return new engine.Engine(options);
 }
 
-export * as Engine from "./engine/interfaces";
-export * as Runner from "./runner/interfaces";
-export * as Queue from "./queue/interfaces";
-export * as Task from "./task/interfaces";
+export * as engine from "./engine";
+export * as runners from "./runners";
+export * as queues from "./queues";
+export * as tasks from "./tasks";
 
 export { createEngine };

package/src/{queue → queues}/index.ts

@@ -1,7 +1,7 @@
 // clever-queue
 
 import * as _ from "../helpers";
-import * as Task from "../task";
+import * as cqTask from "../tasks";
 import { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
 
 type GetSumWeightFunction = (priority: number) => number;
@@ -18,12 +18,15 @@ const defaultOptions: Options = {
 class Queue {
   status: Status = "unknown";
   readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+
   tick: number = 0;
-  tasks: Task.Task[] = [];
+  tasks: cqTask.Task[] = [];
 
   constructor(opt: Options) {
     this.status = "initialiazing";
     this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    if (!this.options.id) this.options.id = _.Id.generate();
     if (this.options.autostart) this.start();
   }
 
@@ -43,34 +46,14 @@ class Queue {
     this.status = "stopping";
   }
 
-  /*
-  async createTask(function_: Task._function): Promise<unknown> {
-    if (typeof function_ !== "function") {
-      console.error("raisong Task.ErrorsList.FunctionIsNotAFunction", Task.ErrorsList.FunctionIsNotAFunction);
-      throw new _.Errors.CQError(Task.ErrorsList.FunctionIsNotAFunction);
-    }
-    return new Promise((resolve, reject) => {
-      try {
-        const taskRunner = async (): Promise<void> => {
-          console.log("running Task");
-          const result = await function_();
-          console.log("task runned", result);
-          resolve(result);
-        };
-        const task = new Task.Task(taskRunner, {});
-        this.tasks.push(task);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-*/
-  async createTaskAndEnqueue(function_: Task.FunctionToExecute, options: Task.Options): Promise<unknown> {
-    const task = new Task.Task(function_, options);
+  async createTaskAndEnqueue(function_: cqTask.FunctionToExecute, options: cqTask.Options = {}): Promise<unknown> {
+    const task = new cqTask.Task(function_, options);
     return this.enqueue(task);
   }
 
-  async enqueue(task: Task.Task): Promise<unknown> {
+  async enqueue(task: cqTask.Task): Promise<unknown> {
+    task.status = "queued";
+    task.queueId = this.options.id; // store queue that handle task for future references
     return new Promise((resolve, reject) => {
       task.resolver = resolve;
       task.rejecter = reject;
@@ -89,5 +72,5 @@ class Queue {
   }
 }
 
-export { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
+export { Options, Statistics, ErrorsList, Priorities, Weights } from "./interfaces";
 export { Queue, GetSumWeightFunction };

package/src/{queue → queues}/interfaces.ts

@@ -1,9 +1,10 @@
 import * as _ from "../helpers";
 
-const Priorities = { Absolute: 0, Standard: 128, BestEffort: 255 };
+const Priorities = { BestEffort: 0, Standard: 128,  Absolute: 255};
+const Weights = { Lowest: 0, Default: 128, Highest: 255 };
 
 interface Options {
-  name?: string;
+  id?: string;
   priority: number;
   weight: number;
   autostart?: boolean;
@@ -35,4 +36,4 @@ const ErrorsList: {
   NoOptionsOnQueueInitialization: { name: "NoOptionsOnQueueInitialization", message: "You must provide an options parameter to Queue" },
 };
 
-export { Options, Statistics, ErrorsList, Priorities };
+export { Options, Statistics, ErrorsList, Priorities, Weights };

package/src/{runner → runners}/index.ts

@@ -2,11 +2,11 @@
 
 import * as _ from "../helpers";
 import { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
-import { Engine } from "../engine";
+import * as cqEngine from "../engine";
 
 export * from "./interfaces";
 
-type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
+type Status = "unknown" | "initialiazing" | "idle" | "running" | "stopping" | "destroying";
 
 const defaultOptions: Options = {
   priority: Priorities.BestEffort,
@@ -16,14 +16,16 @@ const defaultOptions: Options = {
 
 class Runner {
   status: Status = "unknown";
-  readonly #options: Options;
-  readonly #engine: Engine;
+  readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+  readonly #engine: cqEngine.Engine;
 
-  constructor(opt: Options, engine: Engine) {
+  constructor(opt: Options, engine: cqEngine.Engine) {
     this.status = "initialiazing";
-    this.#options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    if (!this.options.id) this.options.id = _.Id.generate();
     this.#engine = engine; // Store parent engine for later callbacks
-    if (this.#options.autostart) this.start();
+    if (this.options.autostart) this.start();
   }
 
   #checkOptionsConsistancy(options: Options): Options {
@@ -32,18 +34,21 @@ class Runner {
   }
 
   async #run(): Promise<void> {
-    while (this.status === "running") {
+    while (["idle", "running"].includes(this.status)) {
       await new Promise((resolve) => setTimeout(resolve, 10)); // Do not freeze the event loop with infinite loop.
       // get the next task to run according to this runner priority
-      const task = await this.#engine.getNextTask(this.#options.priority);
+      const task = await this.#engine.getNextTask(this.options.priority);
       if (task) {
-        await task.runner();
+        if (this.status === "idle") this.status = "running";
+        task.runnerId = this.options.id; // store runner that handle task for future references
+        await task.run();
+        if (this.status === "running") this.status = "idle";
       }
     }
   }
 
   start(): void {
-    this.status = "running";
+    this.status = "idle";
     this.#run();
   }
 
@@ -54,7 +59,7 @@ class Runner {
   statistics(): Statistics {
     const stat: Statistics = {
       status: this.status,
-      priority: this.#options.priority,
+      priority: this.options.priority,
     };
     return stat;
   }

package/src/{runner → runners}/interfaces.ts

@@ -1,6 +1,7 @@
 import * as _ from "../helpers";
 
 interface Options {
+  id?: string;
   autostart?: boolean;
   priority: number;
   logFunction?: _.Logs.LogFunction;
@@ -20,5 +21,5 @@ const ErrorsList: {
   },
 };
 
-export { Priorities } from "../queue/interfaces";
+export { Priorities } from "../queues/interfaces";
 export { Options, Statistics, ErrorsList };

package/src/{task → tasks}/index.ts

@@ -3,7 +3,7 @@
 import * as _ from "../helpers";
 import { Options, Statistics, ErrorsList, FunctionToExecute } from "./interfaces";
 
-type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
+type Status = "unknown" | "initialiazing" | "queued" | "running" | "runned" | "exception" | "destroying";
 
 const defaultOptions: Options = {
   logFunction: undefined,
@@ -11,10 +11,14 @@ const defaultOptions: Options = {
 
 class Task {
   status: Status = "unknown";
-  readonly #options: Options;
+  readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+  queueId: string | undefined;
+  runnerId: string | undefined;
+
   #functionToExecute: FunctionToExecute;
   result: unknown | undefined = undefined;
-  readonly runner: () => Promise<unknown>;
+  readonly run: () => Promise<unknown>;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   resolver: (value: any | PromiseLike<any>) => void;
@@ -30,21 +34,24 @@ class Task {
 
   constructor(function_: FunctionToExecute, opt: Options) {
     this.status = "initialiazing";
-    this.#options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
-
+    this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    if (!this.options.id) this.options.id = _.Id.generate();
     if (typeof function_ !== "function") throw new _.Errors.CQError(ErrorsList.FunctionIsNotAFunction);
 
     this.resolver = this.#defaultResolver;
     this.rejecter = this.#defaultRejecter;
     this.#functionToExecute = function_;
 
-    this.runner = async (): Promise<void> => {
+    this.run = async (): Promise<void> => {
       this.status = "running";
-      // console.log("running Task");
-      this.result = await this.#functionToExecute();
-      // console.log("task runned", this.result);
-      this.status = "stopping";
-      this.resolver(this.result);
+      try {
+        this.result = await this.#functionToExecute();
+        this.status = "runned";
+        this.resolver(this.result);
+      } catch (error) {
+        this.status = "exception";
+        this.rejecter(new _.Errors.CQError(ErrorsList.FunctionRaisedAnHundledException));
+      }
     };
   }
 

package/src/{task → tasks}/interfaces.ts

@@ -4,6 +4,7 @@ import * as _ from "../helpers";
 type FunctionToExecute = (...arguments_: any[]) => Promise<any> | void;
 
 interface Options {
+  id?: string;
   timeout?: number;
   logFunction?: _.Logs.LogFunction;
 }
@@ -12,7 +13,7 @@ interface Statistics {
   status: string;
 }
 
-type ErrorListKeys = "NoOptionsOnTaskInitialization" | "FunctionIsNotAFunction" | "TaskRunnerNotInitialized";
+type ErrorListKeys = "NoOptionsOnTaskInitialization" | "FunctionIsNotAFunction" | "FunctionRaisedAnHundledException" | "TaskRunnerNotInitialized";
 
 const ErrorsList: {
   [index in ErrorListKeys]: { name: string; message: string };
@@ -25,6 +26,10 @@ const ErrorsList: {
     name: "FunctionIsNotAFunction",
     message: "FunctionIsNotAFunction",
   },
+  FunctionRaisedAnHundledException: {
+    name: "FunctionRaisedAnHundledException",
+    message: "FunctionRaisedAnHundledException",
+  },
   TaskRunnerNotInitialized: {
     name: "TaskRunnerNotInitialized",
     message: "TaskRunnerNotInitialized",

package/test/issues/00001.mjs

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+const engineOptions = {
+  bestEffortRunners: 1,
+  logFunction: undefined,
+};
+
+const task = async (string_) => {
+  // console.log(string_, "Start", new Date());
+  await new Promise((resolve, reject) => setTimeout(reject(string_), 2000));
+  // console.log(string_, "End", new Date());
+  return string_;
+};
+
+describe("Issue #1", () => {
+  it("Exception if function passed raised an exception", () => {
+    const engine = cleverQueue.createEngine(engineOptions);
+    const queue1 = engine.createQueue({
+      name: "A",
+      priority: cleverQueue.queues.Priorities.Absolute,
+      weight: 50,
+    });
+    assert.rejects(
+      async () => {
+        const myTask = engine.createTask(() => task("taskMustFail"), {});
+        await queue1.enqueue(myTask);
+      },
+      { name: "FunctionRaisedAnHundledException" },
+    );
+    engine.stop();
+  });
+});