@woosh/meep-engine 3.30.0 → 3.31.0

package/src/core/parser/simple/readNumberToken.js

@@ -1,5 +1,6 @@
 import { assert } from "../../assert.js";
 import DataType from "./DataType.js";
+import { read_digits } from "./read_digits.js";
 import { readHexToken } from "./readHexToken.js";
 import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.js";
 import { skipWhitespace } from "./skipWhitespace.js";
@@ -60,12 +61,20 @@ export function readNumberToken(text, cursor, length) {
         if (i < length) {
             const dot = text.charAt(i);
             if (dot === '.') {
-                i++;
-                const fraction = readUnsignedIntegerToken(text, i, length);
+                const fraction_start = i + 1;
 
-                const digits = (fraction.end - fraction.start);
+                // read_digits rather than readUnsignedIntegerToken, because a trailing dot with no
+                // fraction after it ('1.') is tolerated here — the whole part is the value and the dot
+                // is consumed. The token reader requires a digit, which is right for its own callers
+                // and wrong for this one, so the tolerance is stated here instead of leaning on a
+                // reader that answered 0 for an empty run.
+                const fraction = read_digits(text, fraction_start, length, 10);
 
-                value += fraction.value / Math.pow(10, digits);
+                const digit_count = fraction.end - fraction_start;
+
+                if (digit_count > 0) {
+                    value += fraction.value / Math.pow(10, digit_count);
+                }
 
                 i = fraction.end;
             }

package/src/core/parser/simple/readUnsignedIntegerToken.d.ts

@@ -1,9 +1,11 @@
 /**
+ * Read a run of decimal digits as an unsigned integer. At least one digit is required.
  *
  * @param {string} text
  * @param {number} cursor
  * @param {number} length
  * @returns {Token}
+ * @throws {ParserError} when there is no digit at `cursor`
  */
 export function readUnsignedIntegerToken(text: string, cursor: number, length: number): Token;
 import Token from "./Token.js";

package/src/core/parser/simple/readUnsignedIntegerToken.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readUnsignedIntegerToken.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/simple/readUnsignedIntegerToken.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,+CALW,MAAM,UACN,MAAM,UACN,MAAM,GACJ,KAAK,CA2DjB;kBAlEiB,YAAY"}
+{"version":3,"file":"readUnsignedIntegerToken.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/simple/readUnsignedIntegerToken.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,+CANW,MAAM,UACN,MAAM,UACN,MAAM,GACJ,KAAK,CAkBjB;kBA1BiB,YAAY"}

package/src/core/parser/simple/readUnsignedIntegerToken.js

@@ -1,71 +1,31 @@
-import { assert } from "../../assert.js";
-import DataType from "./DataType.js";
-import ParserError from "./ParserError.js";
-import Token from "./Token.js";
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-export function readUnsignedIntegerToken(text, cursor, length) {
-    assert.isString(text, 'text');
-    assert.isNonNegativeInteger(cursor, 'cursor');
-    assert.isNonNegativeInteger(length, 'length');
-
-    let i = cursor;
-
-    let value = 0;
-
-    main_loop: for (; i < length;) {
-        const char = text.charAt(i);
-        let digit;
-        switch (char) {
-            case '0':
-                digit = 0;
-                break;
-            case '1':
-                digit = 1;
-                break;
-            case '2':
-                digit = 2;
-                break;
-            case '3':
-                digit = 3;
-                break;
-            case '4':
-                digit = 4;
-                break;
-            case '5':
-                digit = 5;
-                break;
-            case '6':
-                digit = 6;
-                break;
-            case '7':
-                digit = 7;
-                break;
-            case '8':
-                digit = 8;
-                break;
-            case '9':
-                digit = 9;
-                break;
-            default:
-                if (i === cursor) {
-                    //first character is not a digit
-                    throw new ParserError(i, `Expected a digit [0,1,2,3,4,5,6,7,8,9] but got '${char}' instead`, text);
-                }
-                //not a digit
-                break main_loop;
-        }
-        i++;
-        value = value * 10 + digit;
-    }
-
-
-    return new Token(value, cursor, i, "uint", DataType.Number);
-}
-
+import { assert } from "../../assert.js";
+import DataType from "./DataType.js";
+import ParserError from "./ParserError.js";
+import { read_digits } from "./read_digits.js";
+import Token from "./Token.js";
+
+/**
+ * Read a run of decimal digits as an unsigned integer. At least one digit is required.
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ * @throws {ParserError} when there is no digit at `cursor`
+ */
+export function readUnsignedIntegerToken(text, cursor, length) {
+    assert.isString(text, 'text');
+    assert.isNonNegativeInteger(cursor, 'cursor');
+    assert.isNonNegativeInteger(length, 'length');
+
+    const digits = read_digits(text, cursor, length, 10);
+
+    if (digits.end === cursor) {
+        // Either the character here is not a digit, or there is no character here at all. The second
+        // case used to fall through and return a value of 0, because the guard that raised this was
+        // written per-character and end-of-input has no character to look at.
+        throw new ParserError(cursor, `Expected a digit [0,1,2,3,4,5,6,7,8,9] but got '${text.charAt(cursor)}' instead`, text);
+    }
+
+    return new Token(digits.value, cursor, digits.end, "uint", DataType.Number);
+}

package/src/core/parser/simple/read_digits.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Read a run of digits in the given radix, stopping at the first character that is not one.
+ *
+ * This is the loop {@link readUnsignedIntegerToken} and {@link readHexToken} both ran — the same
+ * labelled `for`, the same digit dispatch, the same `value = value * radix + digit` accumulator — in
+ * two copies whose only real difference was the radix. They had drifted on where the "no digits
+ * here" error is raised, so the two are now the same walk and each raises its own error, in its own
+ * wording, after it.
+ *
+ * Nothing is thrown here. `end === from` reports a run of no digits, and the caller decides whether
+ * that is an error: it is for both token readers, and it is not for the fraction after a trailing
+ * `.` in {@link readNumberToken}.
+ *
+ * Not a hot loop — this is a config and expression tokeniser — so the accumulation stays in doubles
+ * and no attempt is made to bound the magnitude.
+ *
+ * @param {string} text
+ * @param {number} from index of the first character to read
+ * @param {number} length index one past the last character that may be read
+ * @param {number} radix 10 or 16
+ * @returns {{value:number, end:number}} `end` is one past the last digit consumed, and equals `from`
+ * when the character at `from` is not a digit of this radix or there is no character there at all
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_digits(text: string, from: number, length: number, radix: number): {
+    value: number;
+    end: number;
+};
+//# sourceMappingURL=read_digits.d.ts.map

package/src/core/parser/simple/read_digits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_digits.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/simple/read_digits.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kCAVW,MAAM,QACN,MAAM,UACN,MAAM,SACN,MAAM,GACJ;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,MAAM,CAAA;CAAC,CA0BtC"}

package/src/core/parser/simple/read_digits.js

@@ -0,0 +1,74 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Value of one character as a digit, or `-1` when it is not a digit in any radix up to 16.
+ *
+ * @param {number} char_code
+ * @returns {number}
+ */
+function digit_value(char_code) {
+    if (char_code >= 48 && char_code <= 57) {
+        // '0'..'9'
+        return char_code - 48;
+    }
+
+    if (char_code >= 97 && char_code <= 102) {
+        // 'a'..'f'
+        return char_code - 87;
+    }
+
+    if (char_code >= 65 && char_code <= 70) {
+        // 'A'..'F'
+        return char_code - 55;
+    }
+
+    return -1;
+}
+
+/**
+ * Read a run of digits in the given radix, stopping at the first character that is not one.
+ *
+ * This is the loop {@link readUnsignedIntegerToken} and {@link readHexToken} both ran — the same
+ * labelled `for`, the same digit dispatch, the same `value = value * radix + digit` accumulator — in
+ * two copies whose only real difference was the radix. They had drifted on where the "no digits
+ * here" error is raised, so the two are now the same walk and each raises its own error, in its own
+ * wording, after it.
+ *
+ * Nothing is thrown here. `end === from` reports a run of no digits, and the caller decides whether
+ * that is an error: it is for both token readers, and it is not for the fraction after a trailing
+ * `.` in {@link readNumberToken}.
+ *
+ * Not a hot loop — this is a config and expression tokeniser — so the accumulation stays in doubles
+ * and no attempt is made to bound the magnitude.
+ *
+ * @param {string} text
+ * @param {number} from index of the first character to read
+ * @param {number} length index one past the last character that may be read
+ * @param {number} radix 10 or 16
+ * @returns {{value:number, end:number}} `end` is one past the last digit consumed, and equals `from`
+ * when the character at `from` is not a digit of this radix or there is no character there at all
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_digits(text, from, length, radix) {
+    assert.isString(text, 'text');
+    assert.isNonNegativeInteger(from, 'from');
+    assert.isNonNegativeInteger(length, 'length');
+    assert.ok(radix === 10 || radix === 16, `radix must be 10 or 16, got '${radix}'`);
+
+    let i = from;
+    let value = 0;
+
+    for (; i < length; i++) {
+        const digit = digit_value(text.charCodeAt(i));
+
+        if (digit === -1 || digit >= radix) {
+            break;
+        }
+
+        value = value * radix + digit;
+    }
+
+    return { value, end: i };
+}

package/src/core/primitives/numbers/number_format_by_thousands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number_format_by_thousands.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/numbers/number_format_by_thousands.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8CAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAOlB"}
+{"version":3,"file":"number_format_by_thousands.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/numbers/number_format_by_thousands.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8CAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAsBlB"}

package/src/core/primitives/numbers/number_format_by_thousands.js

@@ -10,5 +10,20 @@ export function number_format_by_thousands(x, separator = ',') {
     assert.isNumber(x, 'x');
     assert.isString(separator, 'separator');
 
-    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+    const text = x.toString();
+
+    // The lookahead matches wherever a run of digits ends on a multiple of three, and nothing in it
+    // is anchored to the integer part - so the fractional digits were grouped too, turning
+    // 1234.5678 into "1,234.5,678". Group the integer half only, and leave the rest verbatim
+    // (which also covers the "1e+21" that toString produces above 1e21).
+    const point = text.indexOf('.');
+
+    if (point === -1) {
+        return text.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+    }
+
+    const integer_part = text.slice(0, point);
+    const remainder = text.slice(point);
+
+    return integer_part.replace(/\B(?=(\d{3})+(?!\d))/g, separator) + remainder;
 }

package/src/core/primitives/numbers/number_pretty_print.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number_pretty_print.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/numbers/number_pretty_print.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,CAsBlB"}
+{"version":3,"file":"number_pretty_print.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/numbers/number_pretty_print.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,CA2BlB"}

package/src/core/primitives/numbers/number_pretty_print.js

@@ -21,7 +21,12 @@ export function number_pretty_print(value) {
 
     if (would_produce_decimals && Math.abs(value) < 100) {
         const truncated = value.toFixed(MAX_DECIMALS);
-        return string_strip_trailing(truncated, "0");
+
+        const stripped = string_strip_trailing(truncated, "0");
+
+        // when the rounding carries into the integer part the fixed form ends in ".00", and
+        // stripping the zeros leaves the point behind - 99.999 came out as "100."
+        return string_strip_trailing(stripped, ".");
     } else {
         //no fraction
         return number_format_by_thousands(value - fraction, ",");

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

@@ -1 +1 @@
-{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";mBASa,OAAO,iBAAiB,EAAE,IAAI;wBAC9B,OAAO,sBAAsB,EAAE,OAAO;AAYnD;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAES;IAEzB;;;OAGG;IACH,YAFU,IAAI,EAAE,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,oBAFW,SAAS,QAqEnB;IAED;;;OAGG;IACH,mBAFW,SAAS,QAenB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GACH,OAAO,CAwBlB;IAED;;;OAGG;IACH,UAFW,IAAI,QAKd;IAED;;;OAGG;IACH,eAFW,IAAI,EAAE,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBAgDC;IAED;;;;OAIG;IACH,eAHW,IAAI,GACF,OAAO,CAYnB;IA8QD,aAYC;IAED,0BAMC;;CACJ;;;;mBA9mBkB,+BAA+B;wBAknBxC,MAAM"}
+{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";mBASa,OAAO,iBAAiB,EAAE,IAAI;wBAC9B,OAAO,sBAAsB,EAAE,OAAO;AAYnD;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAES;IAEzB;;;OAGG;IACH,YAFU,IAAI,EAAE,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,oBAFW,SAAS,QAqEnB;IAED;;;OAGG;IACH,mBAFW,SAAS,QAmBnB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GACH,OAAO,CA6BlB;IA6BD;;;OAGG;IACH,UAFW,IAAI,QAKd;IAED;;;OAGG;IACH,eAFW,IAAI,EAAE,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBAgDC;IAED;;;;OAIG;IACH,eAHW,IAAI,GACF,OAAO,CAYnB;IA8QD,aAYC;IAED,0BAMC;;CACJ;;;;mBAlpBkB,+BAA+B;wBAspBxC,MAAM"}

package/src/core/process/executor/ConcurrentExecutor.js

@@ -171,6 +171,10 @@ class ConcurrentExecutor {
                 this.removeTask(child);
             }
         }
+
+        // the group itself is not queued - its children are - so it needs its own terminal
+        // transition, or anything awaiting the group stays pending after every child is cancelled
+        this.#cancel(group);
     }
 
     /**
@@ -186,6 +190,9 @@ class ConcurrentExecutor {
         if (readyIndex !== -1) {
             //is in ready queue, remove
             this.queueReady.splice(readyIndex, 1);
+
+            this.#cancel(task);
+
             return true;
         }
 
@@ -195,6 +202,8 @@ class ConcurrentExecutor {
             //found in unresolved queue, remove
             this.queueUnresolved.splice(unresolvedIndex, 1);
 
+            this.#cancel(task);
+
             return true;
         }
 
@@ -202,6 +211,33 @@ class ConcurrentExecutor {
         return false;
     }
 
+    /**
+     * Give a removed task a terminal outcome.
+     *
+     * Removal used to only splice the task out of its queue: the task stayed RUNNING for ever, its
+     * promise never settled, and anything awaiting it - including the enclosing group, which counts
+     * it as still pending - hung. `TaskState.CANCELLED` exists for exactly this and was written
+     * nowhere in the scheduler.
+     *
+     * @param {Task|TaskGroup} task
+     */
+    #cancel(task) {
+        const state = task.state.getValue();
+
+        if (
+            state === TaskState.SUCCEEDED
+            || state === TaskState.FAILED
+            || state === TaskState.CANCELLED
+        ) {
+            // already terminal, nothing to announce
+            return;
+        }
+
+        task.state.set(TaskState.CANCELLED);
+
+        task.on.cancelled.send0();
+    }
+
     /**
      *
      * @param {Task} task

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

@@ -71,6 +71,14 @@ export class Task {
          * @type {Signal}
          */
         readonly failed: Signal;
+        /**
+         * Removed from its executor before reaching a terminal state. This is a terminal outcome
+         * like {@link failed}: without it, a removed task sat in RUNNING forever and every promise
+         * joined to it stayed pending.
+         * @readonly
+         * @type {Signal}
+         */
+        readonly cancelled: Signal;
     };
     /**
      *

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":"AAoBA;;;GAGG;AACH;IA+NI;;;;OAIG;IACH,yBAHW,MAAM,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;IA9PD;;;;;;;;;;OAUG;IACH;QAR4B,IAAI,GAArB,MAAM;QACuD,WAAW,GAAxE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI;QACnB,aAAa,QAAjC,UAAU;QACO,eAAe,SAAhC,MAAM;QACA,YAAY,GAA7B,IAAI,EAAE;QACW,iBAAiB,GAAlC,MAAM;OAwDhB;IA9GD;;;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;IA6BrB;;;OAGG;IACH,cAFU,IAAI,EAAE,CAEgB;IAEhC;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFsB,UAAU,CAEN;IAE1B;;;OAGG;IACH,YAFU,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAE/B;IAWjC,0BAUC;IAED;;;OAGG;IACH,sBAFa,MAAM,CAIlB;IAED,+BAEC;IAED;;;;OAIG;IACH,oBAHW,IAAI,GAAC,SAAS,QAuBxB;IAED;;;OAGG;IACH,uBAFW,MAAM,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,QAWjC;IAED,mBAEC;IAED;;;;OAIG;IACH,gDAEC;IAED;;OAEG;IACH,sBAkBC;IAED;;;OAGG;IACH,wBAEC;IAmFL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CANpB;;iCA5TY,OAAO,mCAAmC,EAAE,OAAO;wBACnD,OAAO,gBAAgB,EAAE,OAAO;mBAT1B,+BAA+B;4BAGtB,gCAAgC;2BACjC,iBAAiB"}
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/task/Task.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH;IAuOI;;;;OAIG;IACH,yBAHW,MAAM,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,gBAOjC;IAED;;;OAGG;IACH,qBAFW,IAAI,GAAC,SAAS,gBAIxB;IAED;;;;;OAKG;IACH,kBAJW,IAAI,6CAwBd;IAED;;;;;OAKG;IACH,sBAJW,IAAI,EAAE,6CAgChB;IAjQD;;;;;;;;;;OAUG;IACH;QAR4B,IAAI,GAArB,MAAM;QACuD,WAAW,GAAxE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI;QACnB,aAAa,QAAjC,UAAU;QACO,eAAe,SAAhC,MAAM;QACA,YAAY,GAA7B,IAAI,EAAE;QACW,iBAAiB,GAAlC,MAAM;OAwDhB;IAtHD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH;QACI;;;WAGG;0BADO,MAAM;QAGhB;;;WAGG;4BADO,MAAM;QAGhB;;;WAGG;yBADO,MAAM;QAGhB;;;;;;WAMG;4BADO,MAAM;MAGlB;IAEF;;;OAGG;IACH,OAFU,eAAe,CAEsB;IAE/C;;;;OAIG;IACH,0BAHU,MAAM,CAGM;IACtB;;;;OAIG;IACH,6BAHU,MAAM,CAGS;IA6BrB;;;OAGG;IACH,cAFU,IAAI,EAAE,CAEgB;IAEhC;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFsB,UAAU,CAEN;IAE1B;;;OAGG;IACH,YAFU,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAE/B;IAWjC,0BAUC;IAED;;;OAGG;IACH,sBAFa,MAAM,CAIlB;IAED,+BAEC;IAED;;;;OAIG;IACH,oBAHW,IAAI,GAAC,SAAS,QAuBxB;IAED;;;OAGG;IACH,uBAFW,MAAM,CAAC,IAAI,GAAC,SAAS,CAAC,CAAC,QAWjC;IAED,mBAEC;IAED;;;;OAIG;IACH,gDAEC;IAED;;OAEG;IACH,sBAkBC;IAED;;;OAGG;IACH,wBAEC;IAsFL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CANpB;;iCAvUY,OAAO,mCAAmC,EAAE,OAAO;wBACnD,OAAO,gBAAgB,EAAE,OAAO;mBAT1B,+BAA+B;4BAGtB,gCAAgC;2BACjC,iBAAiB"}

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

@@ -48,6 +48,14 @@ export class Task {
          * @type {Signal}
          */
         failed: new Signal(),
+        /**
+         * Removed from its executor before reaching a terminal state. This is a terminal outcome
+         * like {@link failed}: without it, a removed task sat in RUNNING forever and every promise
+         * joined to it stayed pending.
+         * @readonly
+         * @type {Signal}
+         */
+        cancelled: new Signal(),
     };
 
     /**
@@ -277,7 +285,9 @@ export class Task {
         const state = task.state.getValue();
         if (state === TaskState.SUCCEEDED) {
             resolve();
-        } else if (state === TaskState.FAILED) {
+        } else if (state === TaskState.FAILED || state === TaskState.CANCELLED) {
+            // CANCELLED is terminal like FAILED: a caller waiting on a task that was removed from
+            // its executor has to be told, or it waits for ever
             if (reject !== undefined) {
                 reject();
             }
@@ -285,6 +295,7 @@ export class Task {
             task.on.completed.addOne(resolve);
             if (reject !== undefined) {
                 task.on.failed.addOne(reject);
+                task.on.cancelled.addOne(reject);
             }
         }
     }

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

@@ -21,6 +21,12 @@ declare class TaskGroup {
         started: Signal;
         completed: Signal;
         failed: Signal;
+        /**
+         * Removed from its executor before reaching a terminal state. See the note on
+         * {@link Task}'s signal of the same name; `Task.join` treats it as a rejection, and
+         * `join` is what a group is awaited through.
+         */
+        cancelled: Signal;
     };
     /**
      *

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,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,QAAQ,OAAO,CAAC,CAI5B;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;iBA5NgB,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,EAoChB;IA7BG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,CAAC,IAAI,GAAC,SAAS,CAAC,EAAE,CAEJ;IAExB;;;;QAII;;;;WAIG;;MAEN;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,QAAQ,OAAO,CAAC,CAI5B;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;iBAlOgB,WAAW;mBAHT,+BAA+B;4BAEtB,gCAAgC"}

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

@@ -33,7 +33,13 @@ class TaskGroup {
         this.on = {
             started: new Signal(),
             completed: new Signal(),
-            failed: new Signal()
+            failed: new Signal(),
+            /**
+             * Removed from its executor before reaching a terminal state. See the note on
+             * {@link Task}'s signal of the same name; `Task.join` treats it as a rejection, and
+             * `join` is what a group is awaited through.
+             */
+            cancelled: new Signal()
         };
 
         /**

package/src/core/process/undo/ActionProcessor.d.ts

@@ -115,6 +115,18 @@ export class ActionProcessor<C, M> {
      * @private
      */
     private __unsafe_mark;
+    /**
+     * Trim the history down to whichever of the two budgets binds first.
+     *
+     * NOTE: they are budgets in different units, and the previous version mixed them -
+     * `min2(marks.length, this.historyMemoryLimit)`, a count against a byte count. With the default
+     * 268435456-byte limit that was always `marks.length`, so the trimming block never ran at all
+     * and `historyMarkLimit` was a no-op; lower the memory limit to make the cap real and the block
+     * finally ran, computing `lastMark - this.historyMarkLimit`, a negative index into `marks`,
+     * and dereferenced `undefined`.
+     *
+     * Each policy names a first-mark-to-keep of its own here, and the stricter one wins.
+     */
     cleanupHistory(): void;
     /**
      *

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

@@ -1 +1 @@
-{"version":3,"file":"ActionProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/ActionProcessor.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IA4DI;;;;OAIG;IACH,0BAMC;IAtED;;;OAGG;IACH,SAFU,YAAY,CAED;IAErB;;;OAGG;IACH,OAFU,MAAM,KAAK,CAAC,CAAC,CAAC,CAEb;IAEX;;OAEG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,kBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,oBAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,aAFU,OAAO,CAAC,CAAC,GAAG,MAAM,CAED;IAE3B;;;OAGG;IACH,eAFU,OAAO,CAAC,CAAC,GAAG,MAAM,CAEC;IAE7B;;;;;;;;;OASG;IACH,uBAAmC;IAQ/B;;;OAGG;IACH,aAAsB;IAG1B;;;;;;;;;;OAUG;IACH,kBAMC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GACJ,CAAC,CAWb;IAED;;OAEG;IACH,cAGC;IAED;;;;;;;;OAQG;IACH,wBAFW,MAAM,QAyChB;IAED;;;OAGG;IACH,kBAFW,CAAC,iBAIX;IAED;;;OAGG;IACH,sBAyBC;IAED,uBA2BC;IAED;;;;;OAKG;IACH,2CAcC;IAED;;;;;OAKG;IACH,4BAJW,CAAC,GACC,OAAO,CAKnB;IAED;;;;;;OAMG;IACH,4BAyDC;IAED,sBAEC;IAED;;;;OAIG;IACH,sBAmCC;IAED;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,sBA0BC;IAED;;;;;;OAMG;IACH,gBAFW,QAAQ,iBAUlB;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,oBAgCC;CACJ;iBAtfgB,+BAA+B;qBAG3B,WAAW;mBAFb,+BAA+B"}
+{"version":3,"file":"ActionProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/ActionProcessor.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IA4DI;;;;OAIG;IACH,0BAMC;IAtED;;;OAGG;IACH,SAFU,YAAY,CAED;IAErB;;;OAGG;IACH,OAFU,MAAM,KAAK,CAAC,CAAC,CAAC,CAEb;IAEX;;OAEG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,kBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,oBAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,aAFU,OAAO,CAAC,CAAC,GAAG,MAAM,CAED;IAE3B;;;OAGG;IACH,eAFU,OAAO,CAAC,CAAC,GAAG,MAAM,CAEC;IAE7B;;;;;;;;;OASG;IACH,uBAAmC;IAQ/B;;;OAGG;IACH,aAAsB;IAG1B;;;;;;;;;;OAUG;IACH,kBAMC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GACJ,CAAC,CAWb;IAED;;OAEG;IACH,cAGC;IAED;;;;;;;;OAQG;IACH,wBAFW,MAAM,QAyChB;IAED;;;OAGG;IACH,kBAFW,CAAC,iBAIX;IAED;;;OAGG;IACH,sBAyBC;IAED;;;;;;;;;;;OAWG;IACH,uBAyCC;IAED;;;;;OAKG;IACH,2CAcC;IAED;;;;;OAKG;IACH,4BAJW,CAAC,GACC,OAAO,CAKnB;IAED;;;;;;OAMG;IACH,4BAyDC;IAED,sBAEC;IAED;;;;OAIG;IACH,sBAmCC;IAED;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,sBA0BC;IAED;;;;;;OAMG;IACH,gBAFW,QAAQ,iBAUlB;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,oBAgCC;CACJ;iBAhhBgB,+BAA+B;qBAG3B,WAAW;mBAFb,+BAA+B"}

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

@@ -224,33 +224,59 @@ export class ActionProcessor {
         this.cleanupHistory();
     }
 
+    /**
+     * Trim the history down to whichever of the two budgets binds first.
+     *
+     * NOTE: they are budgets in different units, and the previous version mixed them -
+     * `min2(marks.length, this.historyMemoryLimit)`, a count against a byte count. With the default
+     * 268435456-byte limit that was always `marks.length`, so the trimming block never ran at all
+     * and `historyMarkLimit` was a no-op; lower the memory limit to make the cap real and the block
+     * finally ran, computing `lastMark - this.historyMarkLimit`, a negative index into `marks`,
+     * and dereferenced `undefined`.
+     *
+     * Each policy names a first-mark-to-keep of its own here, and the stricter one wins.
+     */
     cleanupHistory() {
         const marks = this.marks;
 
-        let lastMark = min2(marks.length, this.historyMemoryLimit) - 1;
-
-        if (this.historyMemoryUsage >= this.historyMemoryLimit) {
-
-
-            for (; lastMark > 0 && marks[lastMark].memoryUsage > this.historyMemoryUsage; lastMark--) {
-            }
-
+        const mark_count = marks.length;
 
+        if (mark_count === 0) {
+            return;
         }
 
-        if (lastMark + 1 < marks.length) {
-            const marksToDrop = lastMark - this.historyMarkLimit;
+        // count policy: at most `historyMarkLimit` marks are kept
+        let first_keep = 0;
 
-            //get first mark to keep
-            const newFirstMark = marks[marksToDrop];
+        if (mark_count > this.historyMarkLimit) {
+            first_keep = mark_count - this.historyMarkLimit;
+        }
 
-            //drop history before first mark's index
-            this.dropHistory(newFirstMark.index);
+        // Memory policy. `mark.memoryUsage` is the cumulative usage as of that mark, so the bytes
+        // still held once everything before mark `i` is dropped is the difference from the current
+        // total. The last mark is never dropped: it is the one just added, and a single action
+        // larger than the whole budget must not take itself out with the rest.
+        const memory_usage = this.historyMemoryUsage;
+
+        while (
+            first_keep < mark_count - 1
+            && memory_usage - marks[first_keep].memoryUsage > this.historyMemoryLimit
+            ) {
+            first_keep++;
+        }
 
-            assert.equal(newFirstMark.index, 0, "New First Mark's index must be 0");
+        if (first_keep <= 0) {
+            return;
         }
 
+        // `dropHistory` drops every mark whose index is at or before the cut, so it is handed the
+        // index of the LAST mark being dropped - everything after that survives. Doing it the other
+        // way round, by the first mark to keep, would take that mark with it.
+        const last_dropped = marks[first_keep - 1];
+
+        this.dropHistory(last_dropped.index);
 
+        assert.equal(marks.length, mark_count - first_keep, 'cleanup must keep exactly the marks from first_keep onward');
     }
 
     /**

package/src/core/process/worker/OnDemandWorkerManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OnDemandWorkerManager.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/OnDemandWorkerManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAwBI;;;OAGG;IACH,iCAOC;IAjCD;;;;OAIG;IACH,wBAAoB;IAEpB;;;;;OAKG;IACH,qBAAoB;IAEpB;;;;OAIG;IACH,8BAA2B;IASvB;;OAEG;IACH,oBAAoB;IAGxB;;;;;OAKG;IACH,qBAFW,MAAM,QAMhB;IAED;;OAEG;IACH,kBAKC;IAED;;OAEG;IACH,mCASC;IAED;;;OAGG;IACH,6BAFW,MAAM,QAMhB;IAED;;OAEG;IACH,kBAMC;IAED;;OAEG;IACH,kBAeC;IAGD;;;;;;OAMG;IACH,iBAJW,MAAM,kCAahB;CACJ"}
+{"version":3,"file":"OnDemandWorkerManager.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/OnDemandWorkerManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAwBI;;;OAGG;IACH,iCAOC;IAjCD;;;;OAIG;IACH,wBAAoB;IAEpB;;;;;OAKG;IACH,qBAAoB;IAEpB;;;;OAIG;IACH,8BAA2B;IASvB;;OAEG;IACH,oBAAoB;IAGxB;;;;;OAKG;IACH,qBAFW,MAAM,QAMhB;IAED;;OAEG;IACH,kBAKC;IAED;;OAEG;IACH,mCASC;IAED;;;OAGG;IACH,6BAFW,MAAM,QAMhB;IAED;;OAEG;IACH,kBAMC;IAED;;OAEG;IACH,kBAeC;IAGD;;;;;;OAMG;IACH,iBAJW,MAAM,kCAkBhB;CACJ"}

package/src/core/process/worker/OnDemandWorkerManager.js

@@ -132,7 +132,12 @@ export class OnDemandWorkerManager {
 
         const promise = this.worker.$submitRequest(name, parameters);
 
-        promise.finally(this.decrement);
+        // `finally` returns a *new* promise that rejects with the same reason, and discarding it
+        // leaves that rejection unhandled - an `unhandledrejection` in the browser, a process exit
+        // under Node's default policy - even though the caller attached its own catch to `promise`.
+        // Handling both outcomes settles the derived promise instead of abandoning it, which is
+        // what `PromiseWatcher.add` and `ConcurrencyGate` both already do and say.
+        promise.then(this.decrement, this.decrement);
 
         return promise;
     }

package/src/core/process/worker/WorkerBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkerBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/WorkerBuilder.js"],"names":[],"mappings":";AAQA;IAEI;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IACb,YAAa;IACb;;;OAGG;IACH,WAFU;QAAC,CAAC,WAAU;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,EAAE,CAEtB;IACf,sBAA6B;IAE7B;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,WAAS,MAAM,QAIzB;IAED;;;;;OAKG;IACH,6CAKC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,SAFa,WAAW,CA2HvB;CACJ;wBA3LuB,8BAA8B;wBAC9B,kBAAkB"}
+{"version":3,"file":"WorkerBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/WorkerBuilder.js"],"names":[],"mappings":";AAQA;IAEI;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IACb,YAAa;IACb;;;OAGG;IACH,WAFU;QAAC,CAAC,WAAU;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,EAAE,CAEtB;IACf,sBAA6B;IAE7B;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,WAAS,MAAM,QAIzB;IAED;;;;;OAKG;IACH,6CAKC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,SAFa,WAAW,CAiJvB;CACJ;wBAjNuB,8BAA8B;wBAC9B,kBAAkB"}