dcp-client 5.4.0 → 5.4.2

package/generated/sandbox-definitions.json

@@ -1 +1 @@
-{"browser":["deny-node","kvin/kvin.js","script-load-wrapper","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","worktimes","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","pyodide-core","calculate-capabilities","bootstrap"],"node":["kvin/kvin.js","sa-ww-simulation","script-load-wrapper","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","worktimes","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","pyodide-core","calculate-capabilities","bootstrap"],"native":["deny-node","kvin/kvin.js","sa-ww-simulation","script-load-wrapper","native-event-loop","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","worktimes","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","pyodide-core","calculate-capabilities","bootstrap"],"nodeTesting":["kvin/kvin.js","sa-ww-simulation","script-load-wrapper","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","worktimes","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","pyodide-core","calculate-capabilities","bootstrap","testing.js"],"testing":["deny-node","kvin/kvin.js","sa-ww-simulation","script-load-wrapper","native-event-loop","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","worktimes","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","pyodide-core","calculate-capabilities","bootstrap","testing.js"]}
+{"browser":["deny-node","kvin/kvin.js","script-load-wrapper","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","worktimes","pyodide-core","pyodide-worktime","map-basic-worktime","calculate-capabilities","bootstrap"],"node":["kvin/kvin.js","sa-ww-simulation","script-load-wrapper","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","worktimes","pyodide-core","pyodide-worktime","map-basic-worktime","calculate-capabilities","bootstrap"],"native":["deny-node","kvin/kvin.js","sa-ww-simulation","script-load-wrapper","native-event-loop","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","worktimes","pyodide-core","pyodide-worktime","map-basic-worktime","calculate-capabilities","bootstrap"],"nodeTesting":["kvin/kvin.js","sa-ww-simulation","script-load-wrapper","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","worktimes","pyodide-core","pyodide-worktime","map-basic-worktime","calculate-capabilities","bootstrap","testing.js"],"testing":["deny-node","kvin/kvin.js","sa-ww-simulation","script-load-wrapper","native-event-loop","timer-classes","wrap-event-listeners","event-loop-virtualization","lift-webgl","lift-wasm","lift-webgpu","url","polyfills","access-lists","fetch-factory","bravojs-init","bravojs/bravo.js","bravojs-env","worktimes","pyodide-core","pyodide-worktime","map-basic-worktime","calculate-capabilities","bootstrap","testing.js"],"worktimes":["pyodide-worktime","map-basic-worktime"]}

package/generated/worktimes.json

@@ -0,0 +1 @@
+[{"name":"map-basic","version":"1.0.0"},{"name":"pyodide","version":"0.28.0"}]

package/lib/get-worktime-info.js

@@ -0,0 +1,44 @@
+/**
+ *  @file       generate-worktime-info.js
+ *              Get the name and version of all worktime files in the libexec directory and export as an array.
+ *              Worktime files are distinguished from other sandbox scripts by the sandbox-definitions.json worktimes field
+ *
+ *  @author     Severn Lortie <severn@distributive.network>
+ *  @date       February 2024
+ */
+
+/**
+ * Require the sandbox scripts and extract the version and name from each worktime. Worktime setup 
+ * scripts differentiated from normal sandbox scripts by the worktimes field in sandbox-definitions.json
+ * Each of these scripts expects self.wrapScriptLoading and protectedStorage to be available, so they
+ * are mocked as necessary.
+ *
+ * @returns {object[]} Worktime info objects ({name: String, version: String}) in descending version order
+ */
+function getWorktimes()
+{
+  const semver = require('semver');
+  const worktimeScripts = require('../generated/sandbox-definitions.json').worktimes;
+  const worktimes = [];
+  function wrapScriptLoading(_, fn)
+  {
+    fn(protectedStorage);
+  }
+  function registerWorktime(worktime)
+  {
+    worktimes.push({ name: worktime.name, version: worktime.version })
+  }
+  const protectedStorage = {};
+  protectedStorage.worktimes = {};
+  protectedStorage.worktimes.registerWorktime = registerWorktime;
+  globalThis.self = {};
+  globalThis.self.wrapScriptLoading = wrapScriptLoading;
+  for (const script of worktimeScripts)
+    require(`../libexec/sandbox/${script}`);
+  worktimes.sort((a, b) => semver.compare(b.version, a.version, true));
+  delete globalThis.self;
+  return worktimes;
+}
+
+const worktimes = getWorktimes();
+module.exports.worktimes = worktimes;

package/libexec/sandbox/bootstrap.js

@@ -268,7 +268,11 @@ self.wrapScriptLoading({ scriptName: 'bootstrap', finalScript: true }, function
       return;
     // Avoid sending duplicate console message data over the network.
     delete lastConsoleLog.message;
-    postMessage({ request: 'console', payload: lastConsoleLog });
-    lastConsoleLog = null;
+    try 
+    {
+      postMessage({ request: 'console', payload: lastConsoleLog });
+      lastConsoleLog = null;
+    }
+    catch (e){}
   };
 });

package/libexec/sandbox/bravojs-env.js

@@ -11,282 +11,50 @@
 
 self.wrapScriptLoading({ scriptName: 'bravojs-env' }, function bravojsEvn$$fn(protectedStorage, _ring2PostMessage, wrapPostMessage)
 {
-  // This file starts at ring 2, but transitions to ring 3 partway through it.
   const ring2PostMessage = self.postMessage;
-  let ring3PostMessage;
-
   bravojs.ww = {}
   bravojs.ww.allDeps = []
   bravojs.ww.provideCallbacks = {}
 
   //Listens for postMessage from the sandbox
-  addEventListener('message', async (event) => {
+  addEventListener('message', async function bravojsEnv$$sandboxPostMessageHandler(event) {
     let message = event
     let indirectEval = eval // eslint-disable-line
-    switch (message.request) {
+    switch (message.request)
+    {
       case 'moduleGroup': /* Outside environment is sending us a module group */
         module.declare = bravojs.ww.groupedModuleDeclare
         let packages = Object.keys(message.data)
 
-        for (let i = 0; i < packages.length; i++) {
+        for (let i = 0; i < packages.length; i++)
+        {
           let fileNames = Object.keys(message.data[packages[i]])
-          for (let j = 0; j < fileNames.length; j++) {
+          for (let j = 0; j < fileNames.length; j++)
+          {
             bravojs.ww.moduleId = packages[i] + '/' + fileNames[j]
-            try {
-              indirectEval(message.data[packages[i]][fileNames[j]], fileNames[j])
-            } catch (error) {
-              throw error
-            }
+            indirectEval(message.data[packages[i]][fileNames[j]], fileNames[j])
           }
         }
 
         delete module.declare
 
-        if (bravojs.ww.provideCallbacks.hasOwnProperty(message.id)) {
+        if (bravojs.ww.provideCallbacks.hasOwnProperty(message.id))
+        {
           bravojs.ww.provideCallbacks[message.id].callback()
           delete bravojs.ww.provideCallbacks[message.id]
         }
         break
       case 'moduleGroupError': /* Outside environment is sending us a module group error report */
-        if (bravojs.ww.provideCallbacks.hasOwnProperty(message.id) && bravojs.ww.provideCallbacks[message.id].onerror) {
-          bravojs.ww.provideCallbacks[message.id].onerror()
-        } else {
-          console.error('moduleGroupError ', message.stack)
-        }
-        break
-
-      /* Sandbox assigned a specific job by supervisor */
-      case 'assign': {
-        let reportError = function bravojsEnv$$sandboxAssignment$reportError(e) {
-          var error = Object.assign({}, e);
-          Object.getOwnPropertyNames(e).forEach((prop) => error[prop] = e[prop]);
-          if (error.stack)
-            error = error.stack.replace(/data:application\/javascript.*?:/g, 'eval:');
-
-          ring2PostMessage({request: 'reject', error});
-        }
-        
-        try {
-          if (typeof module.main !== 'undefined')
-            throw new Error('Main module was provided before job assignment');
-
-          protectedStorage.sandboxConfig = message.sandboxConfig;
-          Object.assign(self.work.job.public, message.job.public); /* override locale-specific defaults if specified */
-          // Load bravojs' module.main with the work function
-          module.declare(message.job.dependencies, async function mainModule(require, exports, module) {
-            try {
-              if (exports.hasOwnProperty('job'))
-                throw new Error("Tried to assign sandbox when it was already assigned"); /* Should be impossible - might happen if throw during assign? */
-              exports.job = false; /* placeholder own property */
-              
-              message.job.requirePath.map(p => require.paths.push(p));
-              message.job.modulePath.map(p => module.paths.push(p));
-              exports.arguments = message.job.arguments;
-              exports.worktime = message.job.worktime;
-
-              switch (message.job.worktime.name)
-              {
-                case 'map-basic':
-                  if (message.job.useStrict)
-                    exports.job = indirectEval(`"use strict"; (${message.job.workFunction})`);
-                  else
-                    exports.job = indirectEval(`(${message.job.workFunction})`);
-                  break;
-                case 'pyodide':
-                  exports.job = await generatePyodideFunction(message.job);
-                  break;
-                default:
-                  throw new Error(`Unsupported worktime: ${message.job.worktime.name}`);
-              }
-            } catch(e) {
-              reportError(e);
-              return;
-            }
-
-            ring2PostMessage({
-              request: 'assigned',
-              jobId: message.job.id,
-            });
-
-            // Now that the evaluator is assigned, wrap post message for ring 3
-            wrapPostMessage();
-            ring3PostMessage = self.postMessage;
-          }); /* end of main module */
-        } catch (error) {
-          reportError(error);
-        }
-        break /* end of assign */
-      }
-      /* Supervisor has asked us to execute the work function. message.data is input datum. */
-      case 'main':
-      {
-        try
-        {
-          await runWorkFunction(message.data);
-        }
-        catch (error)
-        {
-          ring3PostMessage({ request: 'sandboxError', error });
-        }
+        if (bravojs.ww.provideCallbacks.hasOwnProperty(message.id) && bravojs.ww.provideCallbacks[message.id].onerror)
+          bravojs.ww.provideCallbacks[message.id].onerror();
+        else
+          console.error('moduleGroupError ', message.stack);
         break;
-      }
       default:
         break;
     }
   })
 
-  /**
-   * Factory function which generates a "map-basic"-like workFunction
-   * out of a Pyodide Worktime job (Python code, files, env variables).
-   *
-   * It takes any "images" passed in the workFunction "arguments" and
-   * writes them to the in memory filesystem provided by Emscripten.
-   * It adds any environment variables specified in the workFunction
-   * "arguments" to the pseudo-"process" for use.
-   * It globally imports a dcp module with function "set_slice_handler"
-   * which takes a python function as input. The python function passed
-   * to that slice handler is invoked by the function which this
-   * factory function returns.
-   *
-   * @param {Object} job The job data associated with the message
-   * @returns {Function} function pyodideWorkFn(slice) -> result
-   */
-  async function generatePyodideFunction(job)
-  {
-    var pythonSliceHandler;
-
-    const pyodide = await pyodideInit();
-    const sys = pyodide.pyimport('sys');
-
-    const findImports = pyodide.runPython('import pyodide; pyodide.code.find_imports');
-    const findPythonModuleLoader = pyodide.runPython('import importlib; importlib.util.find_spec');
-
-    const parsedArguments = parsePyodideArguments(job.arguments);
-
-    // write images to file and set environment variables
-    const prepPyodide = pyodide.runPython(`
-import tarfile, io
-import os, sys
-
-def prepPyodide(args):
-  for image in args['images']:
-    image = bytes(image)
-    imageFile = io.BytesIO(image)
-    tar = tarfile.open(mode='r', fileobj=imageFile)
-
-    # Don't overwrite directories which corrupts Pyodide's in memory filesystem
-    def safe_extract(tar, path="/"):
-      for member in tar.getmembers():
-          if member.isdir():
-              dir_path = os.path.join(path, member.name)
-              if not os.path.exists(dir_path):
-                  os.makedirs(dir_path)
-          else:
-              tar.extract(member, path)
-    safe_extract(tar)
-
-  for item, value in args['environmentVariables'].items():
-    os.environ[item] = value
-
-  sys.argv.extend(args['sysArgv'])
-
-  return
-
-prepPyodide`);
-
-    prepPyodide(pyodide.toPy(parsedArguments));
-
-    // register the dcp Python module 
-    if (!sys.modules.get('dcp'))
-    {
-      const create_proxy = pyodide.runPython('import pyodide;pyodide.ffi.create_proxy');
-
-      pyodide.registerJsModule('dcp', {
-        set_slice_handler: function pyodide$$dcp$$setSliceHandler(func) {
-          pythonSliceHandler = create_proxy(func);
-        },
-        progress,
-      });
-    }
-    pyodide.runPython( 'import dcp' );
-
-    // attempt to import packages from the package manager (if they're not already loaded)
-    const workFunctionPythonImports = findImports(job.workFunction).toJs();
-    const packageManagerImports = workFunctionPythonImports.filter(x=>!findPythonModuleLoader(x));
-    if (packageManagerImports.length > 0)
-    {
-      await fetchAndInitPyodidePackages(packageManagerImports);
-      await pyodide.loadPackage(packageManagerImports);
-    }
-
-    return workFunctionWrapper;
-
-    /**
-     * Evaluates the Python WorkFunction string and then executes the slice
-     * handler Python function. If no call to `dcp.set_slice_handler` is passed
-     * or a non function is passed to it.
-     * This function specifically only takes one parameter since Pyodide Slice
-     * Handlers only accept one parameter.
-     */
-    async function workFunctionWrapper(datum)
-    {
-      const pyodide = await pyodideInit(); // returns the same promise when called multiple times
-
-      // load and execute the Python Workfunction, this populates the pythonSliceHandler variable
-      await pyodide.runPython(job.workFunction);
-
-      // failure to specify a slice handler is considered an error
-      if (!pythonSliceHandler)
-        throw new Error('ENOSLICEHANDLER: Must specify the slice handler using `dcp.set_slice_handler(fn)`');
-
-      // setting the slice handler to a non function or lambda is not supported
-      else if (typeof pythonSliceHandler !== 'function')
-        throw new Error('ENOSLICEHANDLER: Slice Handler must be a function');
-
-      const sliceHandlerResult = await pythonSliceHandler(pyodide.toPy(datum));
-
-      // if it is a PyProxy, convert its value to JavaScript
-      if (sliceHandlerResult?.toJs)
-        return sliceHandlerResult.toJs();
-
-      return sliceHandlerResult;
-    }
-
-    /*
-     * Refer to the "The Pyodide Worktime"."Work Function (JS)"."Arguments"."Commands"
-     * part of the DCP Worktimes spec.
-     */
-    function parsePyodideArguments(args)
-    {
-      var index = 1;
-      const numArgs = args[0];
-      const images = [];
-      const environmentVariables = {};
-      const sysArgv = args.slice(numArgs);
-
-      while (index < numArgs)
-      {
-        switch (args[index])
-        {
-          case 'gzImage':
-            const image = args[index+1];
-            images.push(image);
-            index+=2;
-            break;
-          case 'env':
-            const env = args[index+1].split(/=(.*)/s);
-            index+=2;
-            environmentVariables[env[0]] = env[1];
-            break;
-          default:
-            throw new Error(`Invalid argument ${args[index]}`);
-        }
-      }
-
-      return { sysArgv, images, environmentVariables };
-    }
-  }
-
   /** A module.declare suitable for running when processing modules arriving as part
   * of a  module group or other in-memory cache.
   */
@@ -296,7 +64,8 @@ prepPyodide`);
 
     if (bravojs.debug && bravojs.debug.match(/\bmoduleCache\b/)) { console.log('Loaded ' + dependencies + ' from group') }
 
-    if (typeof moduleFactory === 'undefined') {
+    if (typeof moduleFactory === 'undefined')
+    {
       moduleFactory = dependencies
       dependencies = []
     }
@@ -306,9 +75,8 @@ prepPyodide`);
       dependencies: dependencies
     }
 
-    for (i = 0; i < dependencies.length; i++) {
+    for (i = 0; i < dependencies.length; i++)
       bravojs.ww.allDeps.push(bravojs.makeModuleId(moduleBase, dependencies[i]))
-    }
   }
 
   /** A module.provide suitable for a web worker, which requests modules via message passing.
@@ -335,137 +103,4 @@ prepPyodide`);
       id,
     });
   };
-
-  /* Report metrics to sandbox/supervisor */
-  function reportTimes (metrics)
-  {
-    const { total, webGL, webGPU, CPU } = metrics;
-    ring3PostMessage({ request: 'measurement', total, webGL, webGPU, CPU });
-  }
-
-  /* Report an error from the work function to the supervisor */
-  function reportError (error, metrics)
-  {
-    const err = new Error('initial state');
-
-    for (let prop of [ 'message', 'name', 'code', 'stack', 'lineNumber', 'columnNumber' ])
-    {
-      try
-      {
-        if (typeof error[prop] !== 'undefined')
-          err[prop] = error[prop];
-      }
-      catch(e){};
-    }
-
-    reportTimes(metrics); // Report metrics for both 'workReject' and 'workError'.
-    ring3PostMessage({ request: 'workError', error: err });
-  }
-
-  /**
-   * Report a result from work function and metrics to the supervisor.
-   * @param     result  the value that the work function returned promise resolved to
-   */
-  function reportResult (result, metrics)
-  {
-    try
-    {
-      reportTimes(metrics);
-      ring3PostMessage({ request: 'complete', result });
-    }
-    catch (error)
-    {
-      ring3PostMessage({ request: 'sandboxError', error });
-    }
-  }
-  
-  /**
-   * Actual mechanics for running a work function. ** This function will never reject **
-   *
-   * @param     successCallback         callback to invoke when the work function has finished running;
-   *                                    it receives as its argument the resolved promise returned from
-   *                                    the work function
-   * @param     errorCallback           callback to invoke when the work function rejects. It receives
-   *                                    as its argument the error that it rejected with.
-   * @returns   unused promise   
-   */
-  async function runWorkFunction_inner(datum, wallDuration, successCallback, errorCallback)
-  {
-    /** @typedef {import("./timer-classes.js").TimeInterval} TimeInterval */
-    var rejection = false;
-    var result;
-    let metrics;
-    protectedStorage.emitConsoleMessages = true;
-    protectedStorage.flushConsoleBuffer();
-    try
-    {
-      /* module.main.job is the work function; left by assign message */ 
-      result = await module.main.job.apply(null, [datum].concat(module.main.arguments));
-    }
-    catch (error)
-    {
-      rejection = error;
-    }
-
-    try {
-      // reset the device states and flush all pending tasks
-      protectedStorage.lockTimers(); // lock timers so no new timeouts will be run.
-      if (protectedStorage.webGPU)
-        protectedStorage.webGPU.lock();
-
-      // Let microtask queue finish before getting metrics. With all event-loop possibilities locked,
-      // only the microtask could trigger new code, so waiting for a setTimeout guarantees everything's done
-      await new Promise((r) => protectedStorage.realSetTimeout.call(globalThis, r, 1));
-
-      // flush any pending console events, especially in the case of a repeating message that hasn't been emitted yet 
-      // then, disable emission of any more console messages
-      try { protectedStorage.dispatchSameConsoleMessage(); } catch(e) {};
-      protectedStorage.emitConsoleMessages = false;
-
-      metrics = await protectedStorage.bigBrother.globalTrackers.getMetrics();
-
-      await protectedStorage.bigBrother.globalTrackers.reset();
-    } catch (e) {
-      ring3PostMessage({ request: 'sandboxError', error: e });
-    } finally {
-      // due to the nature of the micro task queue, await, our `reset()` cancels all the things that could cause new
-      // tasks, and we wait for all pending task to finish in `reset()`, we are guaranteed to have an empty task queue
-      // now. Hence it's ok to stop the wall clock measurement now
-      wallDuration.stop();
-
-      // safety: wallDuration is always stopped, `length` will not throw
-      metrics = { ...metrics, total: wallDuration.length };
-    }
-
-    if (rejection)
-      errorCallback(rejection, metrics);
-    else
-      successCallback(result, metrics);
-
-    /* CPU time measurement ends when this function's return value is resolved or rejected */
-  }
-
-  /**
-   * Run the work function, returning a promise that resolves once the function has finished
-   * executing.
-   *
-   * @param {datam}     an element of the input set
-   */
-  async function runWorkFunction(datum)
-  {
-    // reset the time used for feature detection
-    protectedStorage.bigBrother.globalTrackers.resetRecordedTime();
-    const wallDuration = new protectedStorage.TimeInterval();
-    protectedStorage.bigBrother.globalTrackers.wallDuration = wallDuration;
-
-    if (protectedStorage.webGPU)
-      protectedStorage.webGPU.unlock();
-    await protectedStorage.unlockTimers();
-
-    /* Use setTimeout trampoline to
-     * 1. shorten stack
-     * 2. initialize the event loop measurement code
-     */
-    protectedStorage.setTimeout(() => runWorkFunction_inner(datum, wallDuration, (result, metrics) => reportResult(result, metrics), (rejection, metrics) => reportError(rejection, metrics)));
-  }
 }); /* end of fn */

package/libexec/sandbox/calculate-capabilities.js

@@ -90,7 +90,7 @@ self.wrapScriptLoading({ scriptName: 'calculate-capabilities' }, function calcul
     addEventListener('message', async (event) => {
       try {
         if (event.request === 'describe') {
-          const worktimes = globalThis.worktimes;
+          const worktimes = protectedStorage.worktimes.getWorktimeList();
           const capabilities = await getCapabilities();
           ring2PostMessage({
             capabilities,

package/libexec/sandbox/map-basic-worktime.js

@@ -0,0 +1,53 @@
+/**
+ *  This file registers the map-basic worktime for DCP. The map-basic worktime is
+ *  the default worktime used with compute.for, compute.do, etc...
+ * 
+ *  Copyright (c) 2018-2024, Distributive, Ltd.  All Rights Reserved.
+ *  @author Severn Lortie <severn@distributive.network>
+ */
+// @ts-nocheck
+self.wrapScriptLoading({ scriptName: 'map-basic-worktime' }, function mapBasicWorktime$$fn(protectedStorage, ring1PostMessage, wrapPostMessage) {
+  let workFunction;
+  let workFunctionArguments;
+  /**
+   * Registers the worktime callbacks that allow the worktime controller (worktimes.js) to setup our environment and run the worktime
+   */
+  function registerWorktime()
+  {
+    protectedStorage.worktimes.registerWorktime({ 
+      name: 'map-basic',
+      version: '1.0.0',
+      initSandbox,
+      processSlice,
+    });
+  }
+
+  /**
+   * Perform setup tasks before processSlice is run
+   * @param {object} job The job assigned to this sandbox
+   */
+  function initSandbox(job)
+  {
+    workFunctionArguments = job.arguments;
+    workFunctionArguments.unshift(false);
+
+    const indirectEval = eval;
+    if (job.useStrict)
+      workFunction = indirectEval(`"use strict"; (${job.workFunction})`);
+    else
+      workFunction = indirectEval(`(${job.workFunction})`);
+  }
+
+  /**
+   * The processSlice hook function which runs the work function for input slice data
+   * @param {*} data The slice data
+   * @returns {*} The slice result
+   */
+  async function processSlice(data)
+  {
+    workFunctionArguments[0] = data;
+    const result = await workFunction.apply(null, workFunctionArguments);
+    return result; 
+  }
+  registerWorktime();
+});