@woosh/meep-engine 2.121.9 → 2.121.12

package/src/core/model/ObservedString.d.ts

@@ -1,4 +1,9 @@
 export default ObservedString;
+/**
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
 declare class ObservedString extends String {
     /**
      *

package/src/core/model/ObservedString.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObservedString.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedString.js"],"names":[],"mappings":";AASA;IACI;;;;OAIG;IACH,oBAHW,MAAM,EAgBhB;IARG;;;;OAIG;IACH,gBAAoB;IAEpB,0DAA6B;IAmBjC;;;;OAIG;IACH,oBAFa,cAAc,CAa1B;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,2BAIC;IAED,iBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAItB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAMtB;IAED,eAEC;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;CAPxC;mBA1HkB,4BAA4B"}
+{"version":3,"file":"ObservedString.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedString.js"],"names":[],"mappings":";AAIA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,oBAHW,MAAM,EAgBhB;IARG;;;;OAIG;IACH,gBAAoB;IAEpB,0DAA6B;IAmBjC;;;;OAIG;IACH,oBAFa,cAAc,CAa1B;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,2BAIC;IAED,iBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAItB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAMtB;IAED,eAEC;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;CAPxC;mBA/HkB,4BAA4B"}

package/src/core/model/ObservedString.js

@@ -1,12 +1,12 @@
-/**
- * @author Alex Goldring 2018
- * @copyright Alex Goldring 2018
- */
-
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { computeStringHash } from "../primitives/strings/computeStringHash.js";
 
+/**
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
 class ObservedString extends String {
     /**
      *

package/src/core/model/node-graph/node/NodeDescription.js

@@ -116,7 +116,7 @@ export class NodeDescription {
      */
     createParameter(name, type, defaultValue) {
 
-        assert.typeOf(name, 'string', 'name');
+        assert.isString(name, 'name');
         assert.enum(type, NodeParameterDataType, 'type');
 
         let _default = defaultValue;
@@ -418,10 +418,10 @@ export class NodeDescription {
      * @param {NodeRegistry} registry
      * @returns {NodeDescription}
      */
-    static fromJSON(j, registry){
+    static fromJSON(j, registry) {
         const r = new NodeDescription();
 
-        r.fromJSON(j,registry);
+        r.fromJSON(j, registry);
 
         return r;
     }

package/src/core/model/node-graph/visual/NodeDescriptionVisualRegistry.js

@@ -113,7 +113,7 @@ export class NodeDescriptionVisualRegistry {
      * @param {NodeVisualData} visual
      */
     add(id, visual) {
-        assert.typeOf(id, 'number', 'id');
+        assert.isNumber(id, 'id');
 
         this.data.set(id, visual);
     }

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.js

@@ -97,8 +97,8 @@ class ExpressionNode {
  * @param {ReactiveExpression} exp
  * @returns {number}
  */
-function scoreByTreeSize(exp){
-    return  exp.computeTreeSize();
+function scoreByTreeSize(exp) {
+    return exp.computeTreeSize();
 }
 
 /**
@@ -368,7 +368,7 @@ export class MultiPredicateEvaluator {
 
             value = expression.evaluate(this.__context);
 
-            if(value === undefined){
+            if (value === undefined) {
                 // value not found
 
                 this.__invalidate_node(node);
@@ -438,7 +438,7 @@ export class MultiPredicateEvaluator {
 
 
     initialize(context) {
-        assert.typeOf(context, 'object', 'context');
+        assert.isObject(context, 'context');
 
         this.__iterator_cursor = 0;
         this.__context = context;

package/src/core/model/reactive/model/terminal/ReactiveReference.js

@@ -14,7 +14,7 @@ export class ReactiveReference extends ReactiveExpression {
      *
      * @param {string} [name]
      */
-    constructor(name="") {
+    constructor(name = "") {
         super();
 
         assert.isString(name, 'name');
@@ -63,9 +63,9 @@ export class ReactiveReference extends ReactiveExpression {
     }
 
     connect(source) {
-        assert.notEqual(source, null, 'source is null');
-        assert.notEqual(source, undefined, 'source is undefined');
-        assert.typeOf(source.onChanged, 'object', 'source.onChanged');
+        assert.notNull(source, 'source');
+        assert.defined(source, 'source');
+        assert.isObject(source.onChanged, 'source.onChanged');
         assert.isFunction(source.onChanged.add, 'source.onChanged.add');
 
         if (this.source !== null) {

package/src/core/process/action/PromiseAsynchronousAction.js

@@ -9,7 +9,7 @@ export class PromiseAsynchronousAction extends AsynchronousAction {
     constructor(factory) {
         super();
 
-        assert.typeOf(factory, 'function', 'factory');
+        assert.isFunction(factory, 'factory');
 
         /**
          *
@@ -33,8 +33,8 @@ export class PromiseAsynchronousAction extends AsynchronousAction {
 
         assert.defined(p, 'factory result');
         assert.notNull(p, 'factory result');
-        assert.typeOf(p, 'object', 'p');
-        assert.typeOf(p.then, 'function', 'p.then');
+        assert.isObject(p, 'p');
+        assert.isFunction(p.then, 'p.then');
 
         p.then(
             () => {

package/src/core/process/action/SynchronousAction.js

@@ -9,7 +9,7 @@ export class SynchronousAction extends AsynchronousAction {
     constructor(factory) {
         super();
 
-        assert.typeOf(factory, 'function', 'factory');
+        assert.isFunction(factory, 'factory');
 
         /**
          *

package/src/core/process/buildPromiseChain.js

@@ -27,11 +27,11 @@ export function buildPromiseChain(
 
             const promise = factory.apply(null, args);
 
-            assert.notEqual(promise, undefined, 'factory result is undefined');
-            assert.notEqual(promise, null, 'factory result is null');
+            assert.defined(promise, 'factory result');
+            assert.notNull(promise, 'factory result');
 
-            assert.typeOf(promise, 'object', 'promise');
-            assert.typeOf(promise.then, 'function', 'promise.then');
+            assert.isObject(promise, 'promise');
+            assert.isFunction(promise.then, 'promise.then');
 
             return promise;
         });

package/src/core/process/executor/ConcurrentExecutor.d.ts

@@ -1,16 +1,104 @@
-import Task from "../task/Task";
-import TaskGroup from "../task/TaskGroup";
-
-export default class ConcurrentExecutor {
-    constructor(quietTime?: number, workTime?: number)
-
-    runGroup(t: TaskGroup): void
-
-    run(t: Task): void
-
-    runMany(tasks: Task[]): void
-
-    removeGroup(t: TaskGroup): void
-
-    removeTask(t: Task): boolean
-}
+export default ConcurrentExecutor;
+/**
+ * @class
+ */
+declare class ConcurrentExecutor {
+    /**
+     *
+     * @param {number} [quietTime] in milliseconds
+     * @param {number} [workTime] in milliseconds
+     * @constructor
+     */
+    constructor(quietTime?: number, workTime?: number);
+    /**
+     *
+     * @type {number}
+     */
+    quietTime: number;
+    /**
+     *
+     * @type {number}
+     */
+    workTime: number;
+    /**
+     * Tasks in state pending resolution or initial sate are put here
+     * @type {Task[]}
+     */
+    queueUnresolved: Task[];
+    /**
+     * ready tasks are those who's dependencies have all been completed
+     * @type {Task[]}
+     */
+    queueReady: Task[];
+    on: {
+        task_started: Signal<any, any, any, any, any, any, any, any>;
+        task_completed: Signal<any, any, any, any, any, any, any, any>;
+        completed: Signal<any, any, any, any, any, any, any, any>;
+    };
+    busy: boolean;
+    /**
+     *
+     * @type {number|SchedulingPolicy}
+     */
+    policy: number | SchedulingPolicy;
+    /**
+     *
+     * @param {TaskGroup} taskGroup
+     */
+    runGroup(taskGroup: TaskGroup): void;
+    /**
+     *
+     * @param {TaskGroup} group
+     */
+    removeGroup(group: TaskGroup): void;
+    /**
+     *
+     * @param {Task} task
+     * @return {boolean}
+     */
+    removeTask(task: Task): boolean;
+    /**
+     *
+     * @param {Task} task
+     */
+    run(task: Task): void;
+    /**
+     * Shortcut for {@link #run} method for scheduling multiple tasks at once
+     * @param {Task[]} tasks
+     */
+    runMany(tasks: Task[]): void;
+    /**
+     * @private
+     * @param {Task} task
+     * @returns {boolean}
+     */
+    private startTask;
+    /**
+     * Go through unresolved queue and move tasks whose dependencies have been completed to ready queue or fail them
+     */
+    resolveTasks(): void;
+    /**
+     *
+     * @param {Task} task
+     * @returns {boolean}
+     */
+    contains(task: Task): boolean;
+    /**
+     * kicks the scheduler into action, this is an internal method and should not be called from outside
+     * @private
+     */
+    private prod;
+    join(callback: any): void;
+    #private;
+}
+declare namespace ConcurrentExecutor {
+    export { SchedulingPolicy as POLICY };
+}
+import Signal from "../../events/signal/Signal.js";
+type SchedulingPolicy = number;
+declare namespace SchedulingPolicy {
+    let ROUND_ROBIN: number;
+    let SEQUENTIAL: number;
+    let TIME_SLICE: number;
+}
+//# sourceMappingURL=ConcurrentExecutor.d.ts.map

package/src/core/process/task/Task.d.ts

@@ -1,15 +1,153 @@
-import {ITask} from "./ITask";
-import {TaskSignal} from "./TaskSignal";
-
-export default class Task extends ITask {
-    constructor(opt: {
-        name: string,
-        initializer?: () => any,
-        cycleFunction: () => TaskSignal,
-        computeProgress?: () => number
-        dependencies?: ITask[],
-        estimatedDuration?: number
-    })
-
-    readonly isTask: boolean
-}
+/**
+ * Represents a computation task, where computation is performed in cycles.
+ * Each cycle is intended to complete very quickly, and be executed by {@link ConcurrentExecutor}
+ */
+export class Task {
+    /**
+     *
+     * @param {Array<(Task|TaskGroup)>} tasks
+     * @return {Promise}
+     */
+    static promiseAll(tasks: Array<(Task | TaskGroup)>): Promise<any>;
+    /**
+     *
+     * @param {Task|TaskGroup} task
+     */
+    static promise(task: Task | TaskGroup): Promise<any>;
+    /**
+     *
+     * @param {Task} task
+     * @param {function} resolve
+     * @param {function} reject
+     */
+    static join(task: Task, resolve: Function, reject: Function): void;
+    /**
+     *
+     * @param {Task[]} tasks
+     * @param {function} resolve
+     * @param {function} reject
+     */
+    static joinAll(tasks: Task[], resolve: Function, reject: Function): void;
+    /**
+     *
+     * @param {string} [name] useful for identifying the task later on, for various UI and debug purposes
+     * @param {function(Task, executor:ConcurrentExecutor)} [initializer] function to be executed just before task starts
+     * @param {function():TaskSignal} cycleFunction
+     * @param {function():number} [computeProgress]
+     * @param {Task[]} [dependencies=[]]
+     * @param {number} [estimatedDuration=1] in seconds
+     * @constructor
+     */
+    constructor({ name, initializer, cycleFunction, computeProgress, dependencies, estimatedDuration }?: string);
+    /**
+     * @readonly
+     * @type {number}
+     */
+    readonly id: number;
+    /**
+     * @readonly
+     */
+    readonly on: {
+        /**
+         * @readonly
+         * @type {Signal}
+         */
+        readonly started: Signal;
+        /**
+         * @readonly
+         * @type {Signal}
+         */
+        readonly completed: Signal;
+        /**
+         * @readonly
+         * @type {Signal}
+         */
+        readonly failed: Signal;
+    };
+    /**
+     *
+     * @type {ObservedInteger}
+     */
+    state: ObservedInteger;
+    /**
+     * amount of time spent running this task in milliseconds
+     * @type {number}
+     * @public
+     */
+    public __executedCpuTime: number;
+    /**
+     * number of time task's cycle function was executed
+     * @type {number}
+     * @public
+     */
+    public __executedCycleCount: number;
+    /**
+     *
+     * @type {Task[]}
+     */
+    dependencies: Task[];
+    /**
+     *
+     * @type {number}
+     */
+    estimatedDuration: number;
+    /**
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {function(): TaskSignal}
+     */
+    cycle: () => TaskSignal;
+    /**
+     *
+     * @type {function(Task, executor:ConcurrentExecutor)}
+     */
+    initialize: (arg0: Task, arg1: executor) => ConcurrentExecutor;
+    computeProgress(): number;
+    /**
+     * Time in milliseconds that the task has been executing for, suspended time does not count
+     * @returns {number}
+     */
+    getExecutedCpuTime(): number;
+    getEstimatedDuration(): number;
+    /**
+     *
+     * @param {Task|TaskGroup} task
+     * @returns Task
+     */
+    addDependency(task: Task | TaskGroup): this;
+    /**
+     *
+     * @param {Array<(Task|TaskGroup)>} tasks
+     */
+    addDependencies(tasks: Array<(Task | TaskGroup)>): void;
+    toString(): string;
+    /**
+     *
+     * @param {function} resolve
+     * @param {function} reject
+     */
+    join(resolve: Function, reject: Function): void;
+    /**
+     * Run entire task synchronously to completion
+     */
+    executeSync(): TaskSignal.EndSuccess | TaskSignal.EndFailure;
+    /**
+     *
+     * @returns {Promise}
+     */
+    promise(): Promise<any>;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTask: boolean;
+}
+export default Task;
+import Signal from "../../events/signal/Signal.js";
+import ObservedInteger from "../../model/ObservedInteger.js";
+import { TaskSignal } from "./TaskSignal.js";
+//# sourceMappingURL=Task.d.ts.map

package/src/core/process/task/Task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/task/Task.js"],"names":[],"mappings":";AAeA;IA+MI;;;;OAIG;IACH,yBAHW,KAAK,CAAC,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,gBAOjC;IAED;;;OAGG;IACH,qBAFW,IAAI,GAAC,SAAS,gBAIxB;IAED;;;;;OAKG;IACH,kBAJW,IAAI,6CAkBd;IAED;;;;;OAKG;IACH,sBAJW,IAAI,EAAE,6CAgChB;IA1PD;;;;;;;;;OASG;IACH,qGARW,MAAM,EA6DhB;IA9FD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;;MAIE;IAEF;;;OAGG;IACH,OAFU,eAAe,CAEsB;IAE/C;;;;OAIG;IACH,0BAHU,MAAM,CAGM;IACtB;;;;OAIG;IACH,6BAHU,MAAM,CAGS;IA4BrB;;;OAGG;IACH,cAFU,IAAI,EAAE,CAEgB;IAEhC;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,MAAY,UAAU,CAEN;IAE1B;;;OAGG;IACH,YAFU,CAAS,IAAI,EAAJ,IAAI,EAAE,IAAQ,EAAR,QAAQ,KAAC,kBAAkB,CAEvB;IAWjC,0BAUC;IAED;;;OAGG;IACH,sBAFa,MAAM,CAIlB;IAED,+BAEC;IAED;;;;OAIG;IACH,oBAHW,IAAI,GAAC,SAAS,QAuBxB;IAED;;;OAGG;IACH,uBAFW,KAAK,CAAC,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,QAWjC;IAED,mBAEC;IAED;;;;OAIG;IACH,gDAEC;IAED;;OAEG;IACH,6DAkBC;IAED;;;OAGG;IACH,wBAEC;IAgFL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CANpB;mBAxSkB,+BAA+B;4BAGtB,gCAAgC;2BACjC,iBAAiB"}
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/task/Task.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IA8NI;;;;OAIG;IACH,yBAHW,KAAK,CAAC,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,gBAOjC;IAED;;;OAGG;IACH,qBAFW,IAAI,GAAC,SAAS,gBAIxB;IAED;;;;;OAKG;IACH,kBAJW,IAAI,6CAqBd;IAED;;;;;OAKG;IACH,sBAJW,IAAI,EAAE,6CAgChB;IA7PD;;;;;;;;;OASG;IACH,qGARW,MAAM,EA6DhB;IA7GD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH;QACI;;;WAGG;0BADO,MAAM;QAGhB;;;WAGG;4BADO,MAAM;QAGhB;;;WAGG;yBADO,MAAM;MAGlB;IAEF;;;OAGG;IACH,OAFU,eAAe,CAEsB;IAE/C;;;;OAIG;IACH,0BAHU,MAAM,CAGM;IACtB;;;;OAIG;IACH,6BAHU,MAAM,CAGS;IA4BrB;;;OAGG;IACH,cAFU,IAAI,EAAE,CAEgB;IAEhC;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,MAAY,UAAU,CAEN;IAE1B;;;OAGG;IACH,YAFU,CAAS,IAAI,EAAJ,IAAI,EAAE,IAAQ,EAAR,QAAQ,KAAC,kBAAkB,CAEvB;IAWjC,0BAUC;IAED;;;OAGG;IACH,sBAFa,MAAM,CAIlB;IAED,+BAEC;IAED;;;;OAIG;IACH,oBAHW,IAAI,GAAC,SAAS,QAuBxB;IAED;;;OAGG;IACH,uBAFW,KAAK,CAAC,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,QAWjC;IAED,mBAEC;IAED;;;;OAIG;IACH,gDAEC;IAED;;OAEG;IACH,6DAkBC;IAED;;;OAGG;IACH,wBAEC;IAmFL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CANpB;;mBA9TkB,+BAA+B;4BAGtB,gCAAgC;2BACjC,iBAAiB"}

package/src/core/process/task/Task.js

@@ -13,17 +13,36 @@ import TaskState from "./TaskState.js";
  */
 let id_counter = 0;
 
-class Task {
+/**
+ * Represents a computation task, where computation is performed in cycles.
+ * Each cycle is intended to complete very quickly, and be executed by {@link ConcurrentExecutor}
+ */
+export class Task {
     /**
      * @readonly
      * @type {number}
      */
     id = id_counter++;
 
+    /**
+     * @readonly
+     */
     on = {
+        /**
+         * @readonly
+         * @type {Signal}
+         */
         started: new Signal(),
+        /**
+         * @readonly
+         * @type {Signal}
+         */
         completed: new Signal(),
-        failed: new Signal()
+        /**
+         * @readonly
+         * @type {Signal}
+         */
+        failed: new Signal(),
     };
 
     /**
@@ -193,7 +212,7 @@ class Task {
      * Run entire task synchronously to completion
      */
     executeSync() {
-        this.initialize(this,null);
+        this.initialize(this, null);
 
         this.on.started.send0();
 
@@ -246,6 +265,9 @@ class Task {
      * @param {function} reject
      */
     static join(task, resolve, reject) {
+        assert.isFunction(resolve, 'resolve');
+        assert.isFunction(reject, 'reject');
+
         const state = task.state.getValue();
         if (state === TaskState.SUCCEEDED) {
             resolve();
@@ -293,7 +315,7 @@ class Task {
         }
 
         for (let i = 0; i < tasks.length; i++) {
-            tasks[i].join(cbOK, cbFailed);
+            Task.join(tasks[i], cbOK, cbFailed);
         }
     }
 }

package/src/core/process/task/TaskGroup.d.ts

@@ -1,5 +1,83 @@
-import {ITask} from "./ITask";
-
-export default class TaskGroup extends ITask {
-    constructor(subtasks: ITask[], name?: string)
-}
+export default TaskGroup;
+declare class TaskGroup {
+    /**
+     *
+     * @param {(Task|TaskGroup)[]} subtasks
+     * @param {string} [name]
+     * @constructor
+     */
+    constructor(subtasks: (Task | TaskGroup)[], name?: string);
+    /**
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {(Task|TaskGroup)[]}
+     */
+    children: (Task | TaskGroup)[];
+    on: {
+        started: Signal<any, any, any, any, any, any, any, any>;
+        completed: Signal<any, any, any, any, any, any, any, any>;
+        failed: Signal<any, any, any, any, any, any, any, any>;
+    };
+    /**
+     *
+     * @type {ObservedInteger}
+     */
+    state: ObservedInteger;
+    /**
+     * Time in milliseconds that the task has been executing for, suspended time does not count
+     * @returns {number}
+     */
+    getExecutedCpuTime(): number;
+    /**
+     *
+     * @param {Task|TaskGroup} child
+     * @returns {boolean}
+     */
+    addChild(child: Task | TaskGroup): boolean;
+    /**
+     *
+     * @param {(Task|TaskGroup)[]} children
+     */
+    addChildren(children: (Task | TaskGroup)[]): void;
+    /**
+     *
+     * @param {Task|TaskGroup} dependency
+     */
+    addDependency(dependency: Task | TaskGroup): void;
+    addDependencies(dependencies: any): void;
+    /**
+     *
+     * @returns {number}
+     */
+    getEstimatedDuration(): number;
+    /**
+     * Dumps task group tree along with state of each task
+     * @returns {string}
+     */
+    getVerboseStatusMessage(): string;
+    computeProgress(): number;
+    /**
+     *
+     * @param resolve
+     * @param reject
+     */
+    join(resolve: any, reject: any): void;
+    /**
+     *
+     * @returns {Promise<unknown>}
+     */
+    promise(): Promise<unknown>;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTaskGroup: boolean;
+}
+import Task from "./Task.js";
+import Signal from "../../events/signal/Signal.js";
+import ObservedInteger from "../../model/ObservedInteger.js";
+//# sourceMappingURL=TaskGroup.d.ts.map

package/src/core/process/task/TaskGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TaskGroup.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/task/TaskGroup.js"],"names":[],"mappings":";AASA;IACI;;;;;OAKG;IACH,sBAJW,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,SAClB,MAAM,EAmChB;IA5BG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,CAEJ;IAExB;;;;MAIC;IAED;;;OAGG;IACH,OAFU,eAAe,CAE0B;IACnD;;;OAGG;IACH,sBAFU,OAAO,CAEM;IAG3B;;;OAGG;IACH,sBAFa,MAAM,CAiBlB;IAED;;;;OAIG;IACH,gBAHW,IAAI,GAAC,SAAS,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,sBAFW,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,QAQ5B;IAED;;;OAGG;IACH,0BAFW,IAAI,GAAC,SAAS,QAkBxB;IAED,yCAUC;IAED;;;OAGG;IACH,wBAFa,MAAM,CAmBlB;IAED;;;OAGG;IACH,2BAFa,MAAM,CAyBlB;IAED,0BAmCC;IAED;;;;OAIG;IACH,sCAEC;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;CACJ;iBAjOgB,WAAW;mBAHT,+BAA+B;4BAEtB,gCAAgC"}
+{"version":3,"file":"TaskGroup.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/task/TaskGroup.js"],"names":[],"mappings":";AASA;IACI;;;;;OAKG;IACH,sBAJW,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,SAClB,MAAM,EA8BhB;IAvBG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,CAEJ;IAExB;;;;MAIC;IAED;;;OAGG;IACH,OAFU,eAAe,CAE0B;IAGvD;;;OAGG;IACH,sBAFa,MAAM,CAiBlB;IAED;;;;OAIG;IACH,gBAHW,IAAI,GAAC,SAAS,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,sBAFW,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,QAQ5B;IAED;;;OAGG;IACH,0BAFW,IAAI,GAAC,SAAS,QAkBxB;IAED,yCAUC;IAED;;;OAGG;IACH,wBAFa,MAAM,CAmBlB;IAED;;;OAGG;IACH,2BAFa,MAAM,CAyBlB;IAED,0BAmCC;IAED;;;;OAIG;IACH,sCAEC;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;iBA5NgB,WAAW;mBAHT,+BAA+B;4BAEtB,gCAAgC"}

package/src/core/process/task/TaskGroup.js

@@ -16,7 +16,7 @@ class TaskGroup {
      */
     constructor(subtasks, name = 'Unnamed') {
         assert.isArray(subtasks, 'subtasks');
-        assert.typeOf(name, 'string', 'name');
+        assert.isString(name, 'name');
 
         /**
          *
@@ -41,11 +41,6 @@ class TaskGroup {
          * @type {ObservedInteger}
          */
         this.state = new ObservedInteger(TaskState.INITIAL);
-        /**
-         * @readonly
-         * @type {boolean}
-         */
-        this.isTaskGroup = true;
     }
 
     /**
@@ -231,6 +226,11 @@ class TaskGroup {
     }
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TaskGroup.prototype.isTaskGroup = true;
 
 /**
  *

package/src/core/process/undo/Action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/Action.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,oBAFa,GAAG;IAGZ;;;OAGG;IACH,mBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,eAFW,GAAG,iBAIb;IAED;;;OAGG;IACH,gBAFW,GAAG,iBAIb;IAGL;;;OAGG;IACH,UAFU,OAAO,CAEQ;CANxB"}
+{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/Action.js"],"names":[],"mappings":"AACA;;;;;;;GAOG;AACH,oBALa,GAAG;IAMZ;;;OAGG;IACH,mBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,eAFW,GAAG,iBAIb;IAED;;;OAGG;IACH,gBAFW,GAAG,iBAIb;IAGL;;;OAGG;IACH,UAFU,OAAO,CAEQ;CANxB"}

package/src/core/process/undo/Action.js

@@ -1,12 +1,11 @@
-/**
- * @author Alex Goldring
- * @copyright Alex Goldring 2017
- */
 
 /**
  * Base class for implementing reversible actions.
  * Actions are intended to be used in conjunction with {@link ActionProcessor}
  * @template CTX
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
  */
 export class Action {
     /**