@woosh/meep-engine 3.30.0 → 3.32.0

package/src/core/math/statistics/computeStatisticalPartialMedian.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStatisticalPartialMedian.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/computeStatisticalPartialMedian.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wDALW,MAAM,EAAE,SACR,MAAM,OACN,MAAM,GACJ,MAAM,CAqBlB"}
+{"version":3,"file":"computeStatisticalPartialMedian.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/computeStatisticalPartialMedian.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,wDALW,MAAM,EAAE,SACR,MAAM,OACN,MAAM,GACJ,MAAM,CAoBlB"}

package/src/core/math/statistics/computeStatisticalPartialMedian.js

@@ -2,10 +2,17 @@ import { assert } from "../../assert.js";
 import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 /**
+ * The median of `values[start..end]` inclusive.
+ *
+ * NOTE: `start`/`end` index the INPUT, not sorted order. This used to sort the whole array and then
+ * index the sorted copy, which is a rank window rather than a value window - so anything outside
+ * `[start, end]` was still sorted in and displaced the window's own values. A caller with a
+ * fixed-capacity backing array (`RingBufferMetric`) got a median drawn from the slots past its
+ * live count. `computeStatisticalPercentile`, whose start/end really are ranks, sorts for itself.
  *
  * @param {number[]} values
- * @param {number} start
- * @param {number} end
+ * @param {number} start first index of the window, inclusive
+ * @param {number} end last index of the window, inclusive
  * @returns {number}
  */
 export function computeStatisticalPartialMedian(values, start, end) {
@@ -18,13 +25,12 @@ export function computeStatisticalPartialMedian(values, start, end) {
 
     assert.lessThanOrEqual(start, end);
 
-    const copy = values.slice();
+    // only the window, so values the caller excluded cannot take part in the ranking
+    const copy = values.slice(start, end + 1);
 
     copy.sort(number_compare_ascending);
 
     const range = end - start;
 
-    const position = start + (range >> 1);
-
-    return copy[position];
+    return copy[range >> 1];
 }

package/src/core/math/statistics/computeStatisticalPercentile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStatisticalPercentile.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/computeStatisticalPercentile.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,qDALW,MAAM,EAAE,kBACR,MAAM,mBACN,MAAM,GACJ,MAAM,CAiBlB"}
+{"version":3,"file":"computeStatisticalPercentile.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/computeStatisticalPercentile.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,qDALW,MAAM,EAAE,kBACR,MAAM,mBACN,MAAM,GACJ,MAAM,CAwBlB"}

package/src/core/math/statistics/computeStatisticalPercentile.js

@@ -1,6 +1,6 @@
 import { assert } from "../../assert.js";
 import { clamp } from "../clamp.js";
-import { computeStatisticalPartialMedian } from "./computeStatisticalPartialMedian.js";
+import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 /**
  *
@@ -23,5 +23,12 @@ export function computeStatisticalPercentile(values, percentile_low, percentile_
     const start = clamp(Math.floor(n * percentile_low), 0, n - 1);
     const end = clamp(Math.ceil(n * percentile_high), 0, n - 1);
 
-    return computeStatisticalPartialMedian(values, start, end);
+    // These are ranks in sorted order, not indices into the input, so the sort has to happen over
+    // the whole array before they mean anything. `computeStatisticalPartialMedian` used to do this
+    // sort on everybody's behalf, which was wrong for callers whose start/end index the input.
+    const sorted = Array.prototype.slice.call(values);
+
+    sorted.sort(number_compare_ascending);
+
+    return sorted[start + ((end - start) >> 1)];
 }

package/src/core/math/statistics/gaussian_amplitude.d.ts

@@ -1,6 +1,15 @@
 /**
+ * Normal PDF parameterised by variance rather than standard deviation:
+ * `1 / sqrt(2 * PI * variance) * exp(-distance^2 / (2 * variance))`.
  *
- * @param {number} variance
+ * The variance-shaped adapter over {@link pdf_normal}, which holds the arithmetic. The two were
+ * written out separately — same function, two parameterisations, two argument orders, and agreeing
+ * only to five digits because this one computed its normaliser and the other carried a truncated
+ * literal for it.
+ *
+ * Adapted from https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx#L339
+ *
+ * @param {number} variance greater than 0
  * @param {number} distance_from_mean
  * @returns {number}
  */

package/src/core/math/statistics/gaussian_amplitude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gaussian_amplitude.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/gaussian_amplitude.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,6CAJW,MAAM,sBACN,MAAM,GACJ,MAAM,CAQlB"}
+{"version":3,"file":"gaussian_amplitude.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/gaussian_amplitude.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,6CAJW,MAAM,sBACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/math/statistics/gaussian_amplitude.js

@@ -1,15 +1,20 @@
-import { gaussian } from "../gaussian.js";
-
-/**
- *
- * @param {number} variance
- * @param {number} distance_from_mean
- * @returns {number}
- */
-export function gaussian_amplitude(variance, distance_from_mean) {
-    // Adapted from https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx#L339
-
-    // gaussian() takes a standard deviation and squares it internally, so pass sqrt(variance) to get
-    // the exponent -distance^2 / (2 * variance) that the 1/sqrt(2*PI*variance) normalization expects.
-    return 1.0 / Math.sqrt(2.0 * Math.PI * variance) * gaussian(Math.sqrt(variance), distance_from_mean);
-}
+import { pdf_normal } from "../physics/pdf/pdf_normal.js";
+
+/**
+ * Normal PDF parameterised by variance rather than standard deviation:
+ * `1 / sqrt(2 * PI * variance) * exp(-distance^2 / (2 * variance))`.
+ *
+ * The variance-shaped adapter over {@link pdf_normal}, which holds the arithmetic. The two were
+ * written out separately — same function, two parameterisations, two argument orders, and agreeing
+ * only to five digits because this one computed its normaliser and the other carried a truncated
+ * literal for it.
+ *
+ * Adapted from https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx#L339
+ *
+ * @param {number} variance greater than 0
+ * @param {number} distance_from_mean
+ * @returns {number}
+ */
+export function gaussian_amplitude(variance, distance_from_mean) {
+    return pdf_normal(distance_from_mean, Math.sqrt(variance));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"BooleanVector3.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BooleanVector3.js"],"names":[],"mappings":"AAGA;IAGI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,MACP,OAAO,EAmBjB;IAzBD,kBAAyB;IAUrB;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IAGd;;;;;OAKG;IACH,OAJW,OAAO,KACP,OAAO,KACP,OAAO,QAoBjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;MAMC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAIC;IAED;;;OAGG;IACH,6CAQC;CACJ;;eAIS,cAAc;;gBAKd,cAAc;;;mBApIL,4BAA4B"}
+{"version":3,"file":"BooleanVector3.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BooleanVector3.js"],"names":[],"mappings":"AAGA;IAGI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,MACP,OAAO,EAmBjB;IAzBD,kBAAyB;IAUrB;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IAGd;;;;;OAKG;IACH,OAJW,OAAO,KACP,OAAO,KACP,OAAO,QAoBjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;MAMC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAIC;IAED;;;OAGG;IACH,6CAQC;CACJ;;eAoBS,cAAc;;gBAKd,cAAc;;;mBApJL,4BAA4B"}

package/src/core/model/BooleanVector3.js

@@ -124,13 +124,29 @@ export class BooleanVector3 {
     }
 }
 
+/**
+ * See {@link ObservedBoolean}'s `make_constant`: freezing the value does not seal the separately
+ * allocated handler map behind its signal, so a frozen constant would otherwise accept subscribers
+ * it can never notify and never release.
+ *
+ * @param {boolean} v
+ * @returns {BooleanVector3}
+ */
+function make_constant(v) {
+    const result = new BooleanVector3(v, v, v);
+
+    result.onChanged.seal();
+
+    return Object.freeze(result);
+}
+
 /**
  * @readonly
  * @type {BooleanVector3}
  */
-BooleanVector3.true = Object.freeze(new BooleanVector3(true, true, true));
+BooleanVector3.true = make_constant(true);
 /**
  * @readonly
  * @type {BooleanVector3}
  */
-BooleanVector3.false = Object.freeze(new BooleanVector3(false, false, false));
+BooleanVector3.false = make_constant(false);

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

@@ -109,6 +109,15 @@ declare class BoundedValue {
      *
      * @param {BinaryBuffer} buffer
      */
+    /**
+     * NOTE: the lower limit is NOT in this record, although {@link equals}, {@link copy} and
+     * {@link toJSON} all carry it. Adding it would change the record length, and this format has no
+     * version field, so every stream written before the change would misparse. Nothing in-tree sets
+     * a non-zero lower limit, so this is a latent gap rather than live loss; closing it needs a
+     * versioned record.
+     *
+     * @param {BinaryBuffer} buffer
+     */
     toBinaryBuffer(buffer: BinaryBuffer): void;
     /**
      *

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

@@ -1 +1 @@
-{"version":3,"file":"BoundedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BoundedValue.js"],"names":[],"mappings":";2BAMa,OAAO,2BAA2B,EAAE,YAAY;AAD7D;;GAEG;AACH;IACI;;;;;;OAMG;IACH,2EA0BC;IAzBG;;;OAGG;IACH,gBAA4D;IAC5D;;;OAGG;IACH,qBAA6D;IAE7D;;;OAGG;IACH,qBAA6D;IAE7D,kBAA6B;IAC7B,mBAA8B;IAC9B,iBAA4B;IAE5B;;;MAGC;IAGL;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,+BAYC;IAED;;;OAGG;IACH,0BAiBC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;;OAGG;IACH,kBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,YAHW,YAAY,GACV,YAAY,CAMxB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAKtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAQtB;CACJ;mBA5NkB,4BAA4B"}
+{"version":3,"file":"BoundedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BoundedValue.js"],"names":[],"mappings":";2BAMa,OAAO,2BAA2B,EAAE,YAAY;AAD7D;;GAEG;AACH;IACI;;;;;;OAMG;IACH,2EA0BC;IAzBG;;;OAGG;IACH,gBAA4D;IAC5D;;;OAGG;IACH,qBAA6D;IAE7D;;;OAGG;IACH,qBAA6D;IAE7D,kBAA6B;IAC7B,mBAA8B;IAC9B,iBAA4B;IAE5B;;;MAGC;IAGL;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,+BAgBC;IAED;;;OAGG;IACH,0BAiBC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;;OAGG;IACH,kBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,YAHW,YAAY,GACV,YAAY,CASxB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;MAcC;IAED,0BAKC;IAED;;;OAGG;IACH;;;;;;;;OAQG;IACH,uBAFW,YAAY,QAKtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAQtB;CACJ;mBAvPkB,4BAA4B"}

package/src/core/model/BoundedValue.js

@@ -86,8 +86,12 @@ class BoundedValue {
 
         this.__limitLower = v;
 
-        //TODO change signal signature to include lower limit
-        this.onChanged.dispatch();
+        // The 4-tuple its two siblings send: (value, upper limit, old value, old upper limit).
+        // A bare `dispatch()` handed every handler written against that shape four `undefined`s.
+        //
+        // TODO the signature still has no room for the lower limit, which is what the old note here
+        //  was about; widening it is a change to every handler, not a bug fix.
+        this.onChanged.send4(this.__value, this.__limitUpper, this.__value, this.__limitUpper);
     }
 
     /**
@@ -158,6 +162,9 @@ class BoundedValue {
      * @returns {BoundedValue}
      */
     copy(other) {
+        // the lower limit too - `equals` compares it, so leaving it behind made `a.copy(b)`
+        // followed by `a.equals(b)` false whenever `b` had a non-zero one
+        this.setLowerLimit(other.getLowerLimit());
         this.setUpperLimit(other.getUpperLimit());
         this.setValue(other.getValue());
         return this;
@@ -187,13 +194,24 @@ class BoundedValue {
     }
 
     toJSON() {
-        return {
+        const result = {
             value: this.__value,
             limit: this.__limitUpper
         };
+
+        // Only when it is not the constructor default, so documents written before this stay
+        // byte-identical. Without it a round trip silently reset a lower limit that `equals`
+        // compares and `getFraction` reads.
+        if (this.__limitLower !== 0) {
+            result.limit_lower = this.__limitLower;
+        }
+
+        return result;
     }
 
     fromJSON(json) {
+        // absent in documents written before the field existed, where it was the default
+        this.setLowerLimit(json.limit_lower !== undefined ? json.limit_lower : 0);
         this.setUpperLimit(json.limit);
         this.setValue(json.value);
     }
@@ -202,6 +220,15 @@ class BoundedValue {
      *
      * @param {BinaryBuffer} buffer
      */
+    /**
+     * NOTE: the lower limit is NOT in this record, although {@link equals}, {@link copy} and
+     * {@link toJSON} all carry it. Adding it would change the record length, and this format has no
+     * version field, so every stream written before the change would misparse. Nothing in-tree sets
+     * a non-zero lower limit, so this is a latent gap rather than live loss; closing it needs a
+     * versioned record.
+     *
+     * @param {BinaryBuffer} buffer
+     */
     toBinaryBuffer(buffer) {
         buffer.writeFloat64(this.__value);
         buffer.writeFloat64(this.__limitUpper);

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

@@ -1 +1 @@
-{"version":3,"file":"ObservedBoolean.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedBoolean.js"],"names":[],"mappings":";2BAKa,OAAO,2BAA2B,EAAE,YAAY;AAD7D;;GAEG;AACH;;;;;;;;;;;;;;GAcG;AACH;IASI;;;;OAIG;IACH,oBAHW,OAAO,EAcjB;IAvBD;;;;OAIG;IACH,wBAAyB;IAYrB;;;;OAIG;IACH,gBAAoB;IAmBxB;;;;OAIG;IACH,WAHW,OAAO,GACL,eAAe,CAa3B;IAED;;;OAGG;IACH,gBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,kBAJoB,OAAO,QAAC,OAAO,0BAEtB,IAAI,CAWhB;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAEC;IAED,kBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAItB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAKtB;IAeL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;IAE3C;;;OAGG;IACH,gBAFsB,MAAM,CAEM;CAxBjC;;eAIS,eAAe;cAMf,eAAe"}
+{"version":3,"file":"ObservedBoolean.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedBoolean.js"],"names":[],"mappings":";2BAKa,OAAO,2BAA2B,EAAE,YAAY;AAD7D;;GAEG;AACH;;;;;;;;;;;;;;GAcG;AACH;IASI;;;;OAIG;IACH,oBAHW,OAAO,EAcjB;IAvBD;;;;OAIG;IACH,wBAAyB;IAYrB;;;;OAIG;IACH,gBAAoB;IAmBxB;;;;OAIG;IACH,WAHW,OAAO,GACL,eAAe,CAa3B;IAED;;;OAGG;IACH,gBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,kBAJoB,OAAO,QAAC,OAAO,0BAEtB,IAAI,CAWhB;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAEC;IAED,kBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAItB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAKtB;IAmCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;IAE3C;;;OAGG;IACH,gBAFsB,MAAM,CAEM;CA5CjC;;eAwBS,eAAe;cAMf,eAAe"}

package/src/core/model/ObservedBoolean.js

@@ -181,17 +181,37 @@ class ObservedBoolean extends Boolean {
     }
 }
 
+/**
+ * A shared value that can never change. `Object.freeze` seals `__value`, but the `Signal` behind
+ * `onChanged` is a separate object with a fully mutable handler map - so the frozen singletons used
+ * to accept subscribers they could never notify and, having no owner, never release: the handler
+ * and its whole closure stayed reachable through the module-level constant for the lifetime of the
+ * program, invisibly, because nothing would ever fire to reveal it.
+ *
+ * Sealing the signal makes that a loud error at the point of attachment instead.
+ *
+ * @param {boolean} value
+ * @returns {ObservedBoolean}
+ */
+function make_constant(value) {
+    const result = new ObservedBoolean(value);
+
+    result.onChanged.seal();
+
+    return Object.freeze(result);
+}
+
 /**
  * @readonly
  * @type {ObservedBoolean}
  */
-ObservedBoolean.FALSE = Object.freeze(new ObservedBoolean(false));
+ObservedBoolean.FALSE = make_constant(false);
 
 /**
  * @readonly
  * @type {ObservedBoolean}
  */
-ObservedBoolean.TRUE = Object.freeze(new ObservedBoolean(true));
+ObservedBoolean.TRUE = make_constant(true);
 
 /**
  * @readonly

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

@@ -1 +1 @@
-{"version":3,"file":"ObservedEnum.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedEnum.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH;;OAsBC;IAlBG;;;;OAIG;IACH,gBAAoB;IACpB;;;;OAIG;IACH,mBAA0B;IAE1B;;;OAGG;IACH,wBAA6B;IAGjC;;;OAGG;IACH;YAFoB,MAAM;MAIzB;IAED;;;;OAIG;IACH,eAFa,YAAY,CAYxB;IAED;;;;OAIG;IACH,uBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAcjB;IAED;;;OAGG;IACH,YAFW,YAAY,QAItB;IAED;;;OAGG;IACH,cAEC;IAED;;;;;OAKG;IACH,8DAFa,IAAI,CAUhB;IAED,cAEC;IAED,yBAEC;CACJ"}
+{"version":3,"file":"ObservedEnum.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedEnum.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH;;OAsBC;IAlBG;;;;OAIG;IACH,gBAAoB;IACpB;;;;OAIG;IACH,mBAA0B;IAE1B;;;OAGG;IACH,wBAA6B;IAGjC;;;OAGG;IACH;YAFoB,MAAM;MAIzB;IAED;;;;OAIG;IACH,eAFa,YAAY,CAYxB;IAED;;;;OAIG;IACH,uBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAkBjB;IAED;;;OAGG;IACH,YAFW,YAAY,QAItB;IAED;;;OAGG;IACH,cAEC;IAED;;;;;OAKG;IACH,8DAFa,IAAI,CAUhB;IAED,cAEC;IAED,yBAEC;CACJ"}

package/src/core/model/ObservedEnum.js

@@ -91,8 +91,12 @@ class ObservedEnum {
     hash() {
         let hash = 0;
 
-        for (const n of this.__validSet) {
-            if(this.__validSet[n] === this.__value)    {
+        // `in`, not `of`: `__validSet` is asserted to be a plain object and has no Symbol.iterator,
+        // so `of` threw a TypeError for every instance, every time - and the body already indexes
+        // the way `in` supplies. NOTE: this ordinal is enumeration-order dependent, so two
+        // instances only hash alike while their valid sets are built in the same order.
+        for (const n in this.__validSet) {
+            if (this.__validSet[n] === this.__value) {
                 break;
             }
 

package/src/core/model/node-graph/NodeGraph.d.ts

@@ -221,10 +221,15 @@ export class NodeGraph {
      * @param {number} sourcePort
      * @param {number} targetNode
      * @param {number} targetPort
+     * @param {number} [id] take this specific id rather than the next free one. Connection ids are
+     *     pooled and re-used, so a document that carries them has to be able to restore them
+     *     verbatim - the way node ids already are - or anything keyed by connection id, such as
+     *     `NodeGraphVisualData`'s routing, lands on the wrong wire after the first
+     *     delete-then-save-then-load cycle.
      * @returns {number} ID of created or already existing connection
      * @throws if any node or port are not found
      */
-    createConnection(sourceNode: number, sourcePort: number, targetNode: number, targetPort: number): number;
+    createConnection(sourceNode: number, sourcePort: number, targetNode: number, targetPort: number, id?: number): number;
     /**
      * Add an existing connection object to the graph. Counterpart of {@link #addNode}.
      * Useful for re-attaching a previously deleted connection while preserving its identity,

package/src/core/model/node-graph/NodeGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/NodeGraph.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH;IAEI;;;;OAIG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,6BAAyB;IAEzB;;;;;OAKG;IACH,4BAA0B;IAE1B;;;;;OAKG;IACH,kCAAgC;IAQhC;;;;OAIG;IACH,sBAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QACI;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;MAEL;IAEF;;OAEG;IACH,cAQC;IAED;;;OAGG;IACH,YAFW,SAAS,QAYnB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;;;OAMG;IACH,aAHW,SAAS,GACP;QAAC,WAAW,EAAC,UAAU,EAAE,CAAC;QAAC,KAAK,EAAC,YAAY,EAAE,CAAA;KAAC,CAe5D;IAED;;;;;;;;;OASG;IACH;QAJmC,KAAK,EAA7B,YAAY,EAAE;QACS,WAAW,GAAlC,UAAU,EAAE;QACV;QAAC,WAAW,EAAC,UAAU,EAAE,CAAC;QAAC,KAAK,EAAC,YAAY,EAAE,CAAA;KAAC,CAmF5D;IAED;;;;OAIG;IACH,8BAHoB,YAAY,+BAK/B;IAED;;;;OAIG;IACH,oCAHoB,UAAU,+BAK7B;IAED;;;;OAIG;IACH,YAFY,YAAY,EAAE,CAIzB;IAED;;;;OAIG;IACH,kBAFY,UAAU,EAAE,CAIvB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAgBnB;IAED;;;;OAIG;IACH,qDAFa,YAAY,EAAE,CAsB1B;IAED;;;;OAIG;IACH,0DAFa,YAAY,EAAE,CAqB1B;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,YAAY,GAAC,SAAS,CAkBlC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,GACJ,YAAY,CAWxB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,UAAU,GAAC,SAAS,CAgBhC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,WACN,MAAM,GACJ,4BAA0B,SAAS,CAY/C;IAED;;;;OAIG;IACH,mCAFa,MAAM,CAclB;IAED;;;OAGG;IACH,cAFW,YAAY,QAkBtB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;;OAQG;IACH,uCANW,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAqClB;IAED;;;;;;;;OAQG;IACH,6BAPW,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAwDlB;IAED;;;;;;;OAOG;IACH,0BAHW,UAAU,GACR,MAAM,CA4BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,OAAO,CA6BnB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,UACN,MAAM,EAAE,GACN,MAAM,CAyBlB;IAED,mBAEC;IAGL;;;;;;;;OAQG;IACH,sBAFU,OAAO,CAEc;;CAX9B;6BA/tB4B,wBAAwB;2BAD1B,iBAAiB"}
+{"version":3,"file":"NodeGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/NodeGraph.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH;IAEI;;;;OAIG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,6BAAyB;IAEzB;;;;;OAKG;IACH,4BAA0B;IAE1B;;;;;OAKG;IACH,kCAAgC;IAQhC;;;;OAIG;IACH,sBAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QACI;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;MAEL;IAEF;;OAEG;IACH,cAQC;IAED;;;OAGG;IACH,YAFW,SAAS,QAYnB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;;;OAMG;IACH,aAHW,SAAS,GACP;QAAC,WAAW,EAAC,UAAU,EAAE,CAAC;QAAC,KAAK,EAAC,YAAY,EAAE,CAAA;KAAC,CAe5D;IAED;;;;;;;;;OASG;IACH;QAJmC,KAAK,EAA7B,YAAY,EAAE;QACS,WAAW,GAAlC,UAAU,EAAE;QACV;QAAC,WAAW,EAAC,UAAU,EAAE,CAAC;QAAC,KAAK,EAAC,YAAY,EAAE,CAAA;KAAC,CAmF5D;IAED;;;;OAIG;IACH,8BAHoB,YAAY,+BAK/B;IAED;;;;OAIG;IACH,oCAHoB,UAAU,+BAK7B;IAED;;;;OAIG;IACH,YAFY,YAAY,EAAE,CAIzB;IAED;;;;OAIG;IACH,kBAFY,UAAU,EAAE,CAIvB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAgBnB;IAED;;;;OAIG;IACH,qDAFa,YAAY,EAAE,CAsB1B;IAED;;;;OAIG;IACH,0DAFa,YAAY,EAAE,CAqB1B;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,YAAY,GAAC,SAAS,CAkBlC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,GACJ,YAAY,CAWxB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,UAAU,GAAC,SAAS,CAgBhC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,WACN,MAAM,GACJ,4BAA0B,SAAS,CAY/C;IAED;;;;OAIG;IACH,mCAFa,MAAM,CAclB;IAED;;;OAGG;IACH,cAFW,YAAY,QAkBtB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;;OAQG;IACH,uCANW,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAqClB;IAED;;;;;;;;;;;;;OAaG;IACH,6BAZW,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,OACN,MAAM,GAKJ,MAAM,CAqElB;IAED;;;;;;;OAOG;IACH,0BAHW,UAAU,GACR,MAAM,CA4BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,OAAO,CA6BnB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,UACN,MAAM,EAAE,GACN,MAAM,CAyBlB;IAED,mBAEC;IAGL;;;;;;;;OAQG;IACH,sBAFU,OAAO,CAEc;;CAX9B;6BAjvB4B,wBAAwB;2BAD1B,iBAAiB"}

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

@@ -577,10 +577,15 @@ export class NodeGraph {
      * @param {number} sourcePort
      * @param {number} targetNode
      * @param {number} targetPort
+     * @param {number} [id] take this specific id rather than the next free one. Connection ids are
+     *     pooled and re-used, so a document that carries them has to be able to restore them
+     *     verbatim - the way node ids already are - or anything keyed by connection id, such as
+     *     `NodeGraphVisualData`'s routing, lands on the wrong wire after the first
+     *     delete-then-save-then-load cycle.
      * @returns {number} ID of created or already existing connection
      * @throws if any node or port are not found
      */
-    createConnection(sourceNode, sourcePort, targetNode, targetPort) {
+    createConnection(sourceNode, sourcePort, targetNode, targetPort, id) {
         assert.isNonNegativeInteger(sourceNode, 'sourceNode');
         assert.isNonNegativeInteger(sourcePort, 'sourcePort');
         assert.isNonNegativeInteger(targetNode, 'targetNode');
@@ -617,8 +622,21 @@ export class NodeGraph {
         connection.setSource(sourceEndpoint);
         connection.setTarget(targetEndpoint);
 
-        const id = this.__idpConnections.get();
-        connection.id = id;
+        let connection_id;
+
+        if (id === undefined) {
+            connection_id = this.__idpConnections.get();
+        } else {
+            assert.isNonNegativeInteger(id, 'id');
+
+            if (this.__idpConnections.getSpecific(id) === false) {
+                throw new Error(`Connection with id '${id}' already exists`);
+            }
+
+            connection_id = id;
+        }
+
+        connection.id = connection_id;
 
         // add connection links to the nodes
         sourceNodeInstance.connections.addUnique(connection);
@@ -632,7 +650,7 @@ export class NodeGraph {
 
         this.#version++;
 
-        return id;
+        return connection_id;
     }
 
     /**

package/src/core/model/node-graph/json/deserializeNodeGraphFromJSON.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deserializeNodeGraphFromJSON.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/json/deserializeNodeGraphFromJSON.js"],"names":[],"mappings":"AAiIA;;;;;;;GAOG;AACH,gJAmEC"}
+{"version":3,"file":"deserializeNodeGraphFromJSON.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/json/deserializeNodeGraphFromJSON.js"],"names":[],"mappings":"AAiIA;;;;;;;GAOG;AACH,gJAqEC"}

package/src/core/model/node-graph/json/deserializeNodeGraphFromJSON.js

@@ -200,6 +200,8 @@ export async function deserializeNodeGraphFromJSON({
         const jSource = jConnection.source;
         const jTarget = jConnection.target;
 
-        graph.createConnection(jSource.instance, jSource.port, jTarget.instance, jTarget.port);
+        //  is undefined in documents written before ids were carried, where the
+        // pool assigns as it always did
+        graph.createConnection(jSource.instance, jSource.port, jTarget.instance, jTarget.port, jConnection.id);
     }
 }

package/src/core/model/node-graph/json/serializeNodeGraphToJSON.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializeNodeGraphToJSON.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/json/serializeNodeGraphToJSON.js"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH;IAJ8B,KAAK;IACqB,WAAW,GAAxD,IAAI,MAAM,EAAE,CAAC,CAAC,KAAQ,QAAW,CAAC;IACV,UAAU,GAAlC,SAAM,MAAM,CAAC;;;;;;;;;EA+EvB"}
+{"version":3,"file":"serializeNodeGraphToJSON.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/json/serializeNodeGraphToJSON.js"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH;IAJ8B,KAAK;IACqB,WAAW,GAAxD,IAAI,MAAM,EAAE,CAAC,CAAC,KAAQ,QAAW,CAAC;IACV,UAAU,GAAlC,SAAM,MAAM,CAAC;;;;;;;;;EAoFvB"}

package/src/core/model/node-graph/json/serializeNodeGraphToJSON.js

@@ -91,6 +91,11 @@ export function serializeNodeGraphToJSON({ graph, serializers = new Map(), class
     graph.traverseConnections(connection => {
 
         connections.push({
+            // Ids are pooled and re-used, so anything keyed by connection id - the visual data's
+            // per-connection routing, for one - needs them restored verbatim, the way node ids
+            // already are. Without this, one delete-then-save-then-load cycle re-numbers every
+            // connection and the routing lands on the wrong wire.
+            id: connection.id,
             source: {
                 instance: connection.source.instance.id,
                 port: connection.source.port.id

package/src/core/model/node-graph/type/DataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/type/DataType.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAyDI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAjFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED;;;MAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}
+{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/type/DataType.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAiEI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAzFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAanB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED;;;MAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}

package/src/core/model/node-graph/type/DataType.js

@@ -36,6 +36,14 @@ export class DataType {
      * @returns {boolean}
      */
     equals(other) {
+        // Reciprocal to ParametricDataType.equals, which rejects anything not parametric. Without
+        // this guard, `plain.equals(parametric)` was true while `parametric.equals(plain)` was
+        // false, so the answer depended on which operand happened to be the receiver - and in a
+        // hashed collection defaulting to `invokeObjectEquals` that is insertion and probe order.
+        if ((this.isParametricDataType === true) !== (other.isParametricDataType === true)) {
+            return false;
+        }
+
         return this.id === other.id
             && this.name === other.name;
     }

package/src/core/model/node-graph/type/ParametricDataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParametricDataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/type/ParametricDataType.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IA+CI;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,sBAUpB;IA3DD;;;OAGG;IACH,YAFU,QAAQ,EAAE,CAEJ;IAGhB;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,QAMpB;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAQnB;IAUD,uBAIC;IAiBD;;;OAGG;IACH,oCAEC;CACJ;yBA5EwB,eAAe"}
+{"version":3,"file":"ParametricDataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/type/ParametricDataType.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAkEI;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,sBAUpB;IA9ED;;;OAGG;IACH,YAFU,QAAQ,EAAE,CAEJ;IAGhB;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,QAMpB;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAQnB;IA6BD,uBAIC;IAiBD;;;OAGG;IACH,oCAEC;CACJ;yBA/FwB,eAAe"}

package/src/core/model/node-graph/type/ParametricDataType.js

@@ -39,6 +39,25 @@ export class ParametricDataType extends DataType {
         return super.equals(other) && isArrayEqual(this.parameters, other.parameters);
     }
 
+    /**
+     * Folds in the parameters, which `equals` compares. Without an override this inherited
+     * `DataType.hash()` - the id alone - so a parametric `list` and a plain `list` of the same id
+     * hashed alike while comparing unequal.
+     *
+     * @returns {number}
+     */
+    hash() {
+        let result = super.hash();
+
+        const parameters = this.parameters;
+
+        for (let i = 0; i < parameters.length; i++) {
+            result = ((result << 5) - result) + parameters[i].hash();
+        }
+
+        return result;
+    }
+
     toJSON() {
         const r = super.toJSON();
 

package/src/core/model/node-graph/visual/NodeGraphVisualData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGraphVisualData.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/visual/NodeGraphVisualData.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,4CAFU,KAAK,CAEyE;AAkBxF;IAEI;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAEnB;IAElB;;;;;;;;OAQG;IACH,aAFU,IAAI,MAAM,EAAE,oBAAoB,CAAC,CAEnB;IAExB;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE,KAAK,CAAC,CAEL;IAEvB;;;;;;;OAOG;IACH,2BAFW,KAAK,QAoCf;IAED;;;;;;;;;OASG;IACH,mCAHW,sBAAsB,GACpB;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAI9D;IAED;;;;;;;;;;OAUG;IACH,kCAHW,sBAAsB,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,cACN,oBAAoB,QAQ9B;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,oBAAoB,GAAC,SAAS,CAI1C;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,oBAAoB,CAgBhC;IAED;;;;;;;;OAQG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,KAAK,QAMf;IAED;;;;;;;;OAQG;IACH,iBAHW,MAAM,GACJ,KAAK,CAIjB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,YAHW,MAAM,QACN,cAAc,QAIxB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,cAAc,GAAC,SAAS,CAIpC;IAED;;;;;;OAMG;IACH,yEAHa,cAAc,CAyB1B;IAED;;;;;OAKG;IACH,wEAIC;IAED;;;;MAwBC;IAED,0BAoCC;CACJ;sBAvWqB,yBAAyB;+BAOhB,qBAAqB;qCAJf,2BAA2B;kBAF9C,gCAAgC;uCAKX,oCAAoC"}
+{"version":3,"file":"NodeGraphVisualData.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/visual/NodeGraphVisualData.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,4CAFU,KAAK,CAEyE;AAkBxF;IAEI;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAEnB;IAElB;;;;;;;;OAQG;IACH,aAFU,IAAI,MAAM,EAAE,oBAAoB,CAAC,CAEnB;IAExB;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE,KAAK,CAAC,CAEL;IAEvB;;;;;;;OAOG;IACH,2BAFW,KAAK,QAoCf;IAED;;;;;;;;;OASG;IACH,mCAHW,sBAAsB,GACpB;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAI9D;IAED;;;;;;;;;;OAUG;IACH,kCAHW,sBAAsB,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,cACN,oBAAoB,QAQ9B;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,oBAAoB,GAAC,SAAS,CAI1C;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,oBAAoB,CAgBhC;IAED;;;;;;;;OAQG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,KAAK,QAMf;IAED;;;;;;;;OAQG;IACH,iBAHW,MAAM,GACJ,KAAK,CAIjB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,YAHW,MAAM,QACN,cAAc,QASxB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,cAAc,GAAC,SAAS,CAIpC;IAED;;;;;;OAMG;IACH,yEAHa,cAAc,CAyB1B;IAED;;;;;OAKG;IACH,wEAIC;IAED;;;;MAwBC;IAED,0BAoCC;CACJ;sBA5WqB,yBAAyB;+BAOhB,qBAAqB;qCAJf,2BAA2B;kBAF9C,gCAAgC;uCAKX,oCAAoC"}

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

@@ -229,6 +229,11 @@ export class NodeGraphVisualData {
      * @param {NodeVisualData} node
      */
     addNode(id, node) {
+        // Stamped, like `addConnection` does. `toJSON` serialises only the objects' own `id` fields
+        // and `fromJSON` re-keys by them, so without this a node added here moved to a different
+        // key on the first save/load - node 7's position landing on node 0.
+        node.id = id;
+
         this.nodes.set(id, node);
     }
 

package/src/core/model/reactive/js/compileReactiveToJS.d.ts

@@ -1,4 +1,26 @@
 /**
+ * Compile a reactive expression to a JavaScript expression, to be evaluated with the scope bound as
+ * `this` — `new Function("return ( " + source + " );").call(scope)`.
+ *
+ * ## Why this is not `ReactiveExpression#toCode()`
+ *
+ * They render the same tree in the same shapes and produce the same string for everything except a
+ * reference, which cannot be shared: `toCode()` renders `a` and this renders `this.a`.
+ *
+ * They are kept apart because they answer different questions. `toCode()` is a *diagnostic* rendering —
+ * every consumer of it in the tree is an assert message, an error message or a debug string — and it
+ * lives on the nodes so a node can describe itself. This is a *code generator*, and what it emits has to
+ * run and has to agree with `transform`. Folding one into the other would mean threading a renderer
+ * through sixteen classes' `toCode()`, for one leaf's difference.
+ *
+ * What protects the other fifteen from drifting apart is a test rather than shared code:
+ * `compileReactiveToJS.spec` asserts that a reference-free expression of every node type renders
+ * identically through both. That was red when it was written — `toCode()` emitted `==` where this emits
+ * `===`, and interpolated string values unescaped where this uses `JSON.stringify`. Both were fixed on
+ * the `toCode()` side, since both were wrong there too.
+ *
+ * Adding a node type means a row in one of the two operator tables above. A node type that reaches here
+ * without one throws by name.
  *
  * @param {ReactiveExpression} exp
  * @return {string}

package/src/core/model/reactive/js/compileReactiveToJS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compileReactiveToJS.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/js/compileReactiveToJS.js"],"names":[],"mappings":"AAmNA;;;;GAIG;AACH,8DAFY,MAAM,CAIjB"}
+{"version":3,"file":"compileReactiveToJS.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/js/compileReactiveToJS.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8DAFY,MAAM,CAIjB"}