@woosh/meep-engine 3.16.0 → 3.17.0

package/editor/view/particles/effect/ParticleNodeParametersView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeParametersView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleNodeParametersView.js"],"names":[],"mappings":"AAmCA;IAOI;;;;;;OAMG;IACH;QALyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAE9D,IAAI;QACG,MAAM,SAA1B,MAAM;OA6BzB;IAxBG,mBAAuC;IAIvC;;OAEG;IACH,mBAAgB;;CAgcvB;iBAtfgB,8BAA8B"}
+{"version":3,"file":"ParticleNodeParametersView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleNodeParametersView.js"],"names":[],"mappings":"AAqCA;IAOI;;;;;;OAMG;IACH;QALyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAE9D,IAAI;QACG,MAAM,SAA1B,MAAM;OA6BzB;IAxBG,mBAAuC;IAIvC;;OAEG;IACH,mBAAgB;;CA0cvB;iBAlgBgB,8BAA8B"}

package/editor/view/particles/effect/ParticleNodeParametersView.js

@@ -9,6 +9,8 @@ import {
     PARTICLE_WIDTH_OPTIONS,
     particle_node_parameters,
 } from "../../../../src/shade/renderer/particles/graph/particle_node_parameters.js";
+import { ParticleCurveEditorView } from "./ParticleCurveEditorView.js";
+import { ParticleGradientEditorView } from "./ParticleGradientEditorView.js";
 
 /**
  * The controls for one particle node's static parameters, drawn inside the node.
@@ -138,6 +140,16 @@ export class ParticleNodeParametersView extends View {
                 control = this.#buildIntegerControl(parameter, value, write);
                 break;
 
+            case PARTICLE_PARAMETER_KIND.CURVE:
+                control = editor_control(new ParticleCurveEditorView({ read: value, write }));
+                break;
+
+            case PARTICLE_PARAMETER_KIND.GRADIENT:
+                control = editor_control(
+                    new ParticleGradientEditorView({ read: value, write, alpha: parameter.alpha !== false })
+                );
+                break;
+
             default:
                 throw new Error(
                     `Particle parameter '${parameter.name}' has kind '${parameter.kind}', which has no control.`
@@ -507,6 +519,27 @@ export class ParticleNodeParametersView extends View {
     }
 }
 
+/**
+ * A control that is a view of its own, in the shape the rest of this file uses.
+ *
+ * The two ramp editors are not built out of `<input>`s the way the rest are — a gradient is a canvas
+ * with a lane of stops under it — so they arrive already made, and all that is left is to say how a
+ * value written from outside reaches them. That is by re-reading rather than by being handed the
+ * value: both hold a working copy that a drag is written into, and re-reading is what throws that
+ * copy away in favour of what the node now says. The node's parameter is already set by the time its
+ * signal arrives, so there is nothing stale to read.
+ *
+ * @param {{refresh: function():void}} editor
+ * @returns {{view: View, write: function(*):void, refresh: function():void}}
+ */
+function editor_control(editor) {
+    return {
+        view: editor,
+        write: () => editor.refresh(),
+        refresh: () => editor.refresh(),
+    };
+}
+
 /**
  * @param {string} type
  * @returns {HTMLInputElement}

package/editor/view/particles/effect/particle-editor.css

@@ -139,6 +139,11 @@
     color: var(--meep-warning, #e2b341);
 }
 
+/* a note is not a problem: it reads as quietly as the graph it is about is running */
+.problem.info {
+    opacity: 0.7;
+}
+
 .problems > .none {
     padding: 4px 10px;
     color: var(--meep-fg-muted, #9da0a3);
@@ -153,6 +158,12 @@
     border-color: var(--meep-warning, #e2b341);
 }
 
+/* nothing reads this node, so it is not compiled — drawn as the aside it is, not as a fault */
+.ui-node-view.has-info {
+    opacity: 0.6;
+    border-style: dashed;
+}
+
 /* --- particle node parameters --------------------------------------------------------------- */
 
 .ui-particle-node-parameters {
@@ -199,6 +210,83 @@
     color: var(--meep-error, #ff7a7a);
 }
 
+/*
+ The ramp controls — a gradient's strip and a curve's plot.
+
+ Both are wider than a label and a field side by side, so their rows put the label on its own line
+ and give the control the width of the node. The canvases scale with the row rather than holding
+ their drawn size: the graph is zoomable, and a control that stayed 208 pixels while everything
+ around it grew would be the one thing on the node that could not be read.
+*/
+
+.ui-particle-node-parameters .parameter-row.kind-gradient,
+.ui-particle-node-parameters .parameter-row.kind-curve {
+    flex-direction: column;
+    align-items: stretch;
+    gap: 3px;
+}
+
+.ui-particle-gradient,
+.ui-particle-curve {
+    display: flex;
+    flex-direction: column;
+    gap: 3px;
+}
+
+.ui-particle-gradient > .strip,
+.ui-particle-curve > .plot {
+    display: block;
+    width: 100%;
+    height: auto;
+    border: 1px solid var(--meep-graph-node-border, #363c46);
+    border-radius: 3px;
+    background: var(--meep-graph-input-bg, #171b21);
+    /* the strip and the plot are both dragged in, and a drag that selects text is a drag that fights */
+    touch-action: none;
+    user-select: none;
+}
+
+.ui-particle-gradient > .stop-fields,
+.ui-particle-curve > .key-fields {
+    display: flex;
+    gap: 2px;
+    align-items: center;
+}
+
+.ui-particle-gradient .swatch {
+    flex: 1 1 auto;
+    min-width: 3em;
+    padding: 0;
+}
+
+.ui-particle-gradient .alpha,
+.ui-particle-gradient .position {
+    flex: 0 0 auto;
+    width: 4em;
+}
+
+.ui-particle-curve .tangents {
+    flex: 1 1 auto;
+}
+
+.ui-particle-gradient .remove,
+.ui-particle-curve .remove {
+    flex: 0 0 auto;
+    width: 1.8em;
+    padding: 2px 0;
+    border: 1px solid var(--meep-graph-node-border, #363c46);
+    border-radius: 3px;
+    background: var(--meep-graph-input-bg, #171b21);
+    color: var(--meep-fg, #d6d8da);
+    cursor: pointer;
+    line-height: 1;
+}
+
+.ui-particle-gradient .remove:hover,
+.ui-particle-curve .remove:hover {
+    background: rgba(255, 255, 255, 0.08);
+}
+
 /* --- code layer ----------------------------------------------------------------------------- */
 
 .ui-particle-code-editor > .header > .authority {
@@ -519,38 +607,38 @@
     border-style: dashed;
     opacity: 0.92;
 }
-
-/*
- A group's name, while an author is inside it. Sized to the text rather than to a form field: it
- lives in a breadcrumb and has to read as part of one until it is being typed in.
-*/
-.ui-particle-graph-editor .group-trail input.rename {
-    width: 11ch;
-    padding: 1px 4px;
-    border: 1px solid transparent;
-    border-radius: 3px;
-    background: transparent;
-    color: inherit;
-    font: inherit;
-}
-
-.ui-particle-graph-editor .group-trail input.rename:hover {
-    border-color: var(--meep-graph-node-border, #363c46);
-}
-
-.ui-particle-graph-editor .group-trail input.rename:focus {
-    outline: none;
-    border-color: var(--meep-accent, #2d7dd2);
-    background: var(--meep-graph-input-bg, #171b21);
-}
-
-/* a command that does not apply to what is selected; the title says why */
-.toolbar-button.disabled {
-    opacity: 0.45;
-    cursor: default;
-}
-
-.toolbar-button.disabled:hover {
-    border-color: transparent;
-    color: var(--meep-fg-muted, #9da0a3);
-}
+
+/*
+ A group's name, while an author is inside it. Sized to the text rather than to a form field: it
+ lives in a breadcrumb and has to read as part of one until it is being typed in.
+*/
+.ui-particle-graph-editor .group-trail input.rename {
+    width: 11ch;
+    padding: 1px 4px;
+    border: 1px solid transparent;
+    border-radius: 3px;
+    background: transparent;
+    color: inherit;
+    font: inherit;
+}
+
+.ui-particle-graph-editor .group-trail input.rename:hover {
+    border-color: var(--meep-graph-node-border, #363c46);
+}
+
+.ui-particle-graph-editor .group-trail input.rename:focus {
+    outline: none;
+    border-color: var(--meep-accent, #2d7dd2);
+    background: var(--meep-graph-input-bg, #171b21);
+}
+
+/* a command that does not apply to what is selected; the title says why */
+.toolbar-button.disabled {
+    opacity: 0.45;
+    cursor: default;
+}
+
+.toolbar-button.disabled:hover {
+    border-color: transparent;
+    color: var(--meep-fg-muted, #9da0a3);
+}

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.16.0",
+  "version": "3.17.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/binary/allocator/OffsetAllocator.d.ts

@@ -1,4 +1,29 @@
 export const ALLOCATOR_NO_SPACE: 4294967295;
+/**
+ * One range handed out by {@link OffsetAllocator#allocate}: where it starts, plus the allocator's
+ * own handle on it. A caller keeps the whole object to give back to {@link OffsetAllocator#free},
+ * or keeps {@link Allocation#metadata} alone and releases it through
+ * {@link OffsetAllocator#free_node}.
+ *
+ * An {@link Allocation} whose `offset` is {@link ALLOCATOR_NO_SPACE} is a failed allocation, not a
+ * range at offset zero — the allocator is out of space, or out of nodes to describe one with.
+ */
+export class Allocation {
+    /**
+     *
+     * @param {number} offset
+     * @param {number} metadata
+     * @return {Allocation}
+     */
+    static from(offset: number, metadata: number): Allocation;
+    /**
+     * @readonly
+     * @type {Allocation}
+     */
+    static readonly INVALID: Allocation;
+    offset: number;
+    metadata: number;
+}
 /**
  * Fast hard realtime O(1) offset allocator with minimal fragmentation.
  *
@@ -106,22 +131,6 @@ export class OffsetAllocator {
     #private;
 }
 import { RowFirstTable } from "../../collection/table/RowFirstTable.js";
-declare class Allocation {
-    /**
-     *
-     * @param {number} offset
-     * @param {number} metadata
-     * @return {Allocation}
-     */
-    static from(offset: number, metadata: number): Allocation;
-    /**
-     * @readonly
-     * @type {Allocation}
-     */
-    static readonly INVALID: Allocation;
-    offset: number;
-    metadata: number;
-}
 declare class StorageReport {
     totalFreeSpace: number;
     largestFreeRegion: number;

package/src/core/binary/allocator/OffsetAllocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OffsetAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/allocator/OffsetAllocator.js"],"names":[],"mappings":"AAaA,4CAA6C;AAyF7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwDI;;;;OAIG;IACH,kBAHW,MAAM,cACN,MAAM,EAYhB;IAtED;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,YAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,OAFU,aAAa,CAEmB;IAE1C;;OAEG;IACH,WAFU,WAAW,CAEX;IAEV;;;OAGG;IACH,YAFU,MAAM,CAED;IAmBf;;;;OAIG;IACH,eAHW,MAAM,GACJ,UAAU,CAkGtB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAqFhB;IAED;;;OAGG;IACH,iBAHW,UAAU,QAUpB;IAqID;;OAEG;IACH,cA4BC;IAED;;;OAGG;IACH,iBAFY,aAAa,CA2BxB;;CACJ;8BAtlB6B,yCAAyC;AAgDvE;IAII;;;;;OAKG;IACH,oBAJW,MAAM,YACN,MAAM,GACL,UAAU,CASrB;IAED;;;OAGG;IACH,yBAFU,UAAU,CAEoE;IAtBxF,eAA4B;IAC5B,iBAA8B;CAsBjC;AAoBD;IACI,uBAAkB;IAClB,0BAAqB;CACxB"}
+{"version":3,"file":"OffsetAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/allocator/OffsetAllocator.js"],"names":[],"mappings":"AAaA,4CAA6C;AAoC7C;;;;;;;;GAQG;AACH;IAII;;;;;OAKG;IACH,oBAJW,MAAM,YACN,MAAM,GACL,UAAU,CASrB;IAED;;;OAGG;IACH,yBAFU,UAAU,CAEoE;IAtBxF,eAA4B;IAC5B,iBAA8B;CAsBjC;AA6BD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwDI;;;;OAIG;IACH,kBAHW,MAAM,cACN,MAAM,EAYhB;IAtED;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,YAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,OAFU,aAAa,CAEmB;IAE1C;;OAEG;IACH,WAFU,WAAW,CAEX;IAEV;;;OAGG;IACH,YAFU,MAAM,CAED;IAmBf;;;;OAIG;IACH,eAHW,MAAM,GACJ,UAAU,CAkGtB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAqFhB;IAED;;;OAGG;IACH,iBAHW,UAAU,QAUpB;IAqID;;OAEG;IACH,cA4BC;IAED;;;OAGG;IACH,iBAFY,aAAa,CA2BxB;;CACJ;8BA/lB6B,yCAAyC;AAqGvE;IACI,uBAAkB;IAClB,0BAAqB;CACxB"}

package/src/core/binary/allocator/OffsetAllocator.js

@@ -47,7 +47,16 @@ const NODE_FIELD_NEIGHBOR_PREV = 4;
 const NODE_FIELD_NEIGHBOR_NEXT = 5;
 const NODE_FIELD_FLAGS = 6;
 
-class Allocation {
+/**
+ * One range handed out by {@link OffsetAllocator#allocate}: where it starts, plus the allocator's
+ * own handle on it. A caller keeps the whole object to give back to {@link OffsetAllocator#free},
+ * or keeps {@link Allocation#metadata} alone and releases it through
+ * {@link OffsetAllocator#free_node}.
+ *
+ * An {@link Allocation} whose `offset` is {@link ALLOCATOR_NO_SPACE} is a failed allocation, not a
+ * range at offset zero — the allocator is out of space, or out of nodes to describe one with.
+ */
+export class Allocation {
     offset = ALLOCATOR_NO_SPACE;
     metadata = ALLOCATOR_NO_SPACE;
 

package/src/core/collection/array/typed/float32_array_hash.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hash of a float32 range, in the terms `===` compares floats in — the counterpart to
+ * {@link uint32_array_hash} for arrays that hold values rather than words.
+ *
+ * The hash reads each element's raw IEEE-754 word, because a float carries distinctions no
+ * integer conversion keeps: `0.5` and `0.25` are different weights and truncate to the same
+ * integer. The one place where the bits say more than the value does is the sign of a zero, and
+ * there the bits are wrong for this purpose: `-0 === +0`, so anything hashing them apart would
+ * disagree with the equality it is meant to accompany. The zero is folded onto `+0`, and every
+ * other value keeps its exact bit pattern.
+ *
+ * A NaN hashes by its bits and so hashes equal to itself, which `===` does not — that direction
+ * is free, as unequal values are always allowed to collide.
+ *
+ * @param {Float32Array} array
+ * @param {number} offset first index to hash
+ * @param {number} length index to stop before, matching {@link uint32_array_hash}
+ * @return {number}
+ */
+export function float32_array_hash(array: Float32Array, offset: number, length: number): number;
+//# sourceMappingURL=float32_array_hash.d.ts.map

package/src/core/collection/array/typed/float32_array_hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float32_array_hash.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/float32_array_hash.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CALW,YAAY,UACZ,MAAM,UACN,MAAM,GACL,MAAM,CAoBjB"}

package/src/core/collection/array/typed/float32_array_hash.js

@@ -0,0 +1,38 @@
+/**
+ * Hash of a float32 range, in the terms `===` compares floats in — the counterpart to
+ * {@link uint32_array_hash} for arrays that hold values rather than words.
+ *
+ * The hash reads each element's raw IEEE-754 word, because a float carries distinctions no
+ * integer conversion keeps: `0.5` and `0.25` are different weights and truncate to the same
+ * integer. The one place where the bits say more than the value does is the sign of a zero, and
+ * there the bits are wrong for this purpose: `-0 === +0`, so anything hashing them apart would
+ * disagree with the equality it is meant to accompany. The zero is folded onto `+0`, and every
+ * other value keeps its exact bit pattern.
+ *
+ * A NaN hashes by its bits and so hashes equal to itself, which `===` does not — that direction
+ * is free, as unequal values are always allowed to collide.
+ *
+ * @param {Float32Array} array
+ * @param {number} offset first index to hash
+ * @param {number} length index to stop before, matching {@link uint32_array_hash}
+ * @return {number}
+ */
+export function float32_array_hash(array, offset, length) {
+    // a Float32Array is 4-byte aligned by construction, so this view always exists
+    const bits = new Uint32Array(array.buffer, array.byteOffset, array.length);
+
+    let hash = length;
+
+    for (let i = offset; i < length; ++i) {
+
+        const value = array[i];
+
+        // `value === 0` is true for both zeroes and for nothing else
+        const word = value === 0 ? 0 : bits[i];
+
+        hash = ((hash << 5) - hash) + word;
+
+    }
+
+    return hash;
+}

package/src/core/graph/csr/CSRGraph.d.ts

@@ -149,7 +149,14 @@ export class CSRGraph {
      */
     clone(): CSRGraph;
     /**
-     * Structural equality — same shape and same buffer contents.
+     * Structural equality — same shape and same contents.
+     *
+     * The three integer arrays compare as words. `edge_weights` compares as floats, by value: a
+     * weight is a measurement, and every consumer of it — `sum_of_edge_weights`, the distance-field
+     * and shortest-path relaxations, metis partitioning — only ever adds or compares it, so `-0` and
+     * `+0` are one weight and no graph behaves differently for holding one rather than the other.
+     * {@link CSRGraph#hash} folds them together to match.
+     *
      * @param {CSRGraph} other
      * @returns {boolean}
      */

package/src/core/graph/csr/CSRGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAkQI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IA7RD;;;;OAIG;IACH,0BAJW,MAAM,oBACN,MAAM,EAgEhB;IAzDG,qBAAqB;IACrB,cADW,MAAM,CACe;IAChC,qBAAqB;IACrB,kBADW,MAAM,CACuB;IAOxC;;;;OAIG;IACH,sBAA4D;IAI5D;;;;OAIG;IACH,gBAFU,WAAW,CAEmE;IAGxF;;;OAGG;IACH,WAFU,WAAW,CAE8D;IAGnF;;;;;OAKG;IACH,cAFU,YAAY,CAEiE;IAGvF;;;;;OAKG;IACH,gBAFU,WAAW,CAE+D;IAGpF;;;OAGG;IACH,qBAFU,MAAM,CAEuB;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAUlB;IAED;;OAEG;IACH,oCAQC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAFW,MAAM,QA6ChB;IAED;;;;;;;;;OASG;IACH,YAFW,QAAQ,QASlB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAMpB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAyBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAiBlB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}
+{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAyQI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IApSD;;;;OAIG;IACH,0BAJW,MAAM,oBACN,MAAM,EAgEhB;IAzDG,qBAAqB;IACrB,cADW,MAAM,CACe;IAChC,qBAAqB;IACrB,kBADW,MAAM,CACuB;IAOxC;;;;OAIG;IACH,sBAA4D;IAI5D;;;;OAIG;IACH,gBAFU,WAAW,CAEmE;IAGxF;;;OAGG;IACH,WAFU,WAAW,CAE8D;IAGnF;;;;;OAKG;IACH,cAFU,YAAY,CAEiE;IAGvF;;;;;OAKG;IACH,gBAFU,WAAW,CAE+D;IAGpF;;;OAGG;IACH,qBAFU,MAAM,CAEuB;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAUlB;IAED;;OAEG;IACH,oCAQC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAFW,MAAM,QA6ChB;IAED;;;;;;;;;OASG;IACH,YAFW,QAAQ,QASlB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAMpB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,QAAQ,GACN,OAAO,CAyBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAiBlB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}

package/src/core/graph/csr/CSRGraph.js

@@ -1,4 +1,5 @@
 import { assert } from "../../assert.js";
+import { float32_array_hash } from "../../collection/array/typed/float32_array_hash.js";
 import { is_typed_array_equals } from "../../collection/array/typed/is_typed_array_equals.js";
 import { uint32_array_hash } from "../../collection/array/typed/uint32_array_hash.js";
 
@@ -241,7 +242,14 @@ export class CSRGraph {
     }
 
     /**
-     * Structural equality — same shape and same buffer contents.
+     * Structural equality — same shape and same contents.
+     *
+     * The three integer arrays compare as words. `edge_weights` compares as floats, by value: a
+     * weight is a measurement, and every consumer of it — `sum_of_edge_weights`, the distance-field
+     * and shortest-path relaxations, metis partitioning — only ever adds or compares it, so `-0` and
+     * `+0` are one weight and no graph behaves differently for holding one rather than the other.
+     * {@link CSRGraph#hash} folds them together to match.
+     *
      * @param {CSRGraph} other
      * @returns {boolean}
      */
@@ -284,11 +292,11 @@ export class CSRGraph {
         // adjacency_length); otherwise two logically-equal graphs with differently-sized buffers hash unequally.
         h = ((h << 5) - h) + uint32_array_hash(this.edge_addresses, 0, this.edge_addresses.length);
         h = ((h << 5) - h) + uint32_array_hash(this.adjacency, 0, this.adjacency.length);
-        // edge_weights is float32; hash its raw IEEE-754 bit pattern via a uint32 view over the
-        // exact same bytes (its own buffer/offset, which need not be __data_buffer if the view was
-        // re-pointed) so fractional weights are distinguished and equal graphs hash equally.
-        const edge_weight_bits = new Uint32Array(this.edge_weights.buffer, this.edge_weights.byteOffset, this.edge_weights.length);
-        h = ((h << 5) - h) + uint32_array_hash(edge_weight_bits, 0, edge_weight_bits.length);
+        // edge_weights is float32, and `equals` compares it as float32 — by value, because a weight
+        // is a measurement. Hashing it must speak the same language: `float32_array_hash` keeps the
+        // bits that carry a value (so fractional weights stay distinct) and folds the one bit that
+        // does not, the sign of a zero, which `-0 === +0` makes invisible to `equals`.
+        h = ((h << 5) - h) + float32_array_hash(this.edge_weights, 0, this.edge_weights.length);
         h = ((h << 5) - h) + uint32_array_hash(this.vertex_weights, 0, this.vertex_weights.length);
         return h | 0;
     }

package/src/core/model/node-graph/visual/layout/LayoutProblem.d.ts

@@ -105,5 +105,29 @@ export class LayoutProblem {
      * @type {Uint8Array}
      */
     to_side: Uint8Array;
+    /**
+     * Link of {@link boxes} each connection became, or -1 for a connection from a node to itself.
+     *
+     * Only meaningful until the lanes go in: {@link layout_insert_lanes} rewrites the links, and
+     * what this indexes afterwards is the links as they were before it.
+     *
+     * @type {Int32Array}
+     */
+    link_of_connection: Int32Array;
+    /**
+     * Where each connection's lanes begin in {@link lane_box}. Length `connection_count + 1`, and
+     * all zero — no lanes at all — until placement has run: a graph being re-routed where it stands
+     * has no lanes, and its wires find their own way.
+     * @type {Int32Array}
+     */
+    lane_start: Int32Array;
+    /**
+     * Lane boxes, grouped by connection and in the order the wire passes through them: the lane in
+     * the column after the source first, the one before the target last. A wire is routed through
+     * its lanes, column by column, so this is what turns the placement's crossing-minimised order
+     * into the drawing rather than leaving the router to rediscover it.
+     * @type {Int32Array}
+     */
+    lane_box: Int32Array;
 }
 //# sourceMappingURL=LayoutProblem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"LayoutProblem.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/LayoutProblem.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;GAYG;AACH,mCANW,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;AA5ID;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;GAEG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;GAEG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;GAEG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;OAEG;IACH,sBAAa;IAEb;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,aAFU,UAAU,CAED;IAEnB;;OAEG;IACH,kBAFU,MAAM,CAEK;IAErB;;OAEG;IACH,eAFU,UAAU,CAEC;IAErB;;;OAGG;IACH,UAFU,UAAU,CAEJ;IAEhB;;OAEG;IACH,QAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,SAFU,YAAY,CAEP;IAEf;;OAEG;IACH,SAFU,YAAY,CAEP;IAEf;;OAEG;IACH,OAFU,YAAY,CAET;IAEb;;OAEG;IACH,OAFU,YAAY,CAET;IAEb;;;OAGG;IACH,WAFU,UAAU,CAEH;IAEjB;;OAEG;IACH,SAFU,UAAU,CAEL;CAClB"}
+{"version":3,"file":"LayoutProblem.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/LayoutProblem.js"],"names":[],"mappings":"AA2IA;;;;;;;;;;;;GAYG;AACH,mCANW,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;AAvKD;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;GAEG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;GAEG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;GAEG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;OAEG;IACH,sBAAa;IAEb;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,aAFU,UAAU,CAED;IAEnB;;OAEG;IACH,kBAFU,MAAM,CAEK;IAErB;;OAEG;IACH,eAFU,UAAU,CAEC;IAErB;;;OAGG;IACH,UAFU,UAAU,CAEJ;IAEhB;;OAEG;IACH,QAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,SAFU,YAAY,CAEP;IAEf;;OAEG;IACH,SAFU,YAAY,CAEP;IAEf;;OAEG;IACH,OAFU,YAAY,CAET;IAEb;;OAEG;IACH,OAFU,YAAY,CAET;IAEb;;;OAGG;IACH,WAFU,UAAU,CAEH;IAEjB;;OAEG;IACH,SAFU,UAAU,CAEL;IAEf;;;;;;;OAOG;IACH,oBAFU,UAAU,CAEM;IAE1B;;;;;OAKG;IACH,YAFU,UAAU,CAEF;IAElB;;;;;;OAMG;IACH,UAFU,UAAU,CAEJ;CACnB"}

package/src/core/model/node-graph/visual/layout/LayoutProblem.js

@@ -108,6 +108,33 @@ export class LayoutProblem {
      * @type {Uint8Array}
      */
     to_side = null;
+
+    /**
+     * Link of {@link boxes} each connection became, or -1 for a connection from a node to itself.
+     *
+     * Only meaningful until the lanes go in: {@link layout_insert_lanes} rewrites the links, and
+     * what this indexes afterwards is the links as they were before it.
+     *
+     * @type {Int32Array}
+     */
+    link_of_connection = null;
+
+    /**
+     * Where each connection's lanes begin in {@link lane_box}. Length `connection_count + 1`, and
+     * all zero — no lanes at all — until placement has run: a graph being re-routed where it stands
+     * has no lanes, and its wires find their own way.
+     * @type {Int32Array}
+     */
+    lane_start = null;
+
+    /**
+     * Lane boxes, grouped by connection and in the order the wire passes through them: the lane in
+     * the column after the source first, the one before the target last. A wire is routed through
+     * its lanes, column by column, so this is what turns the placement's crossing-minimised order
+     * into the drawing rather than leaving the router to rediscover it.
+     * @type {Int32Array}
+     */
+    lane_box = null;
 }
 
 /**

package/src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.d.ts

@@ -71,6 +71,32 @@ export class NodeGraphLayoutOptions {
      * @type {number}
      */
     bend_penalty: number;
+    /**
+     * What crossing another wire costs the router, in the same units as length.
+     *
+     * A crossing is the one thing in a drawing that costs the reader more than a bend: following a
+     * wire through a corner is easy, following it through another wire means deciding which of the
+     * two lines leaving the crossing is the one being followed. So this is above the bend penalty,
+     * and a wire will go about half a channel out of its way to avoid one crossing — and any
+     * distance at all to avoid six, which is what the reader would otherwise get from a wire that
+     * had a route of the same length round the outside and no reason to take it.
+     *
+     * @type {number}
+     */
+    crossing_penalty: number;
+    /**
+     * Rounds of improvement after the negotiation has settled.
+     *
+     * Negotiation asks a wire to look again only when it is sharing a line, so a wire that was
+     * routed early — before most of what it now crosses existed — and shares nothing is never asked
+     * again. Each round here re-routes every wire in turn with all the others present, keeping the
+     * new route only where it is cheaper, and stops as soon as a round changes nothing. Cost can
+     * only fall, so this always settles; the number here is what bounds it on a graph where it is
+     * slow to.
+     *
+     * @type {number}
+     */
+    improvement_rounds: number;
     /**
      * Rounds of rip-up and reroute.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"NodeGraphLayoutOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IAkJI;;;OAGG;IACH,wBAHW,QAAQ,sBAAsB,CAAC,GAC7B,sBAAsB,CAclC;IAhKD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;;;;OAUG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;OAQG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;OAaG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;OAOG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,sBAFU,MAAM,CAEc;CAmBjC"}
+{"version":3,"file":"NodeGraphLayoutOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IA8KI;;;OAGG;IACH,wBAHW,QAAQ,sBAAsB,CAAC,GAC7B,sBAAsB,CAclC;IA5LD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;;;;OAUG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;OAQG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;;;;;;OAWG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;OAWG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;;;;;;;;OAaG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;OAOG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,sBAFU,MAAM,CAEc;CAmBjC"}

package/src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js

@@ -73,6 +73,34 @@ export class NodeGraphLayoutOptions {
      */
     bend_penalty = 40;
 
+    /**
+     * What crossing another wire costs the router, in the same units as length.
+     *
+     * A crossing is the one thing in a drawing that costs the reader more than a bend: following a
+     * wire through a corner is easy, following it through another wire means deciding which of the
+     * two lines leaving the crossing is the one being followed. So this is above the bend penalty,
+     * and a wire will go about half a channel out of its way to avoid one crossing — and any
+     * distance at all to avoid six, which is what the reader would otherwise get from a wire that
+     * had a route of the same length round the outside and no reason to take it.
+     *
+     * @type {number}
+     */
+    crossing_penalty = 60;
+
+    /**
+     * Rounds of improvement after the negotiation has settled.
+     *
+     * Negotiation asks a wire to look again only when it is sharing a line, so a wire that was
+     * routed early — before most of what it now crosses existed — and shares nothing is never asked
+     * again. Each round here re-routes every wire in turn with all the others present, keeping the
+     * new route only where it is cheaper, and stops as soon as a round changes nothing. Cost can
+     * only fall, so this always settles; the number here is what bounds it on a graph where it is
+     * slow to.
+     *
+     * @type {number}
+     */
+    improvement_rounds = 4;
+
     /**
      * Rounds of rip-up and reroute.
      *