@woosh/meep-engine 3.14.6 → 3.16.0

package/src/core/geom/3d/shape/PosedShape3D.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../assert.js";
 import { aabb3_transform_oriented } from "../aabb/aabb3_transform_oriented.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 
@@ -46,9 +47,40 @@ export class PosedShape3D extends AbstractShape3D {
      * @param {Quaternion|{x:number,y:number,z:number,w:number}} rotation
      */
     setup(shape, position, rotation) {
+        // An array-shaped pose - a Float64Array triple, a Transform64's translation view, a literal
+        // [x, y, z] - reads back as undefined here and quietly poses the shape at NaN, where every
+        // support query answers "no hit". Two call sites had done exactly that. Arrays go through
+        // setup_components instead, and this says so rather than silently disappearing.
+        assert.isNumber(position.x, 'position.x');
+        assert.isNumber(rotation.w, 'rotation.w');
+
+        this.setup_components(
+            shape,
+            position.x, position.y, position.z,
+            rotation.x, rotation.y, rotation.z, rotation.w
+        );
+    }
+
+    /**
+     * The same, from loose components.
+     *
+     * A pose does not always arrive as a pair of objects: a `Transform64` keeps its translation and
+     * rotation as numbers inside one buffer, and reading them through its view accessors would build
+     * two throwaway arrays per call, in a loop that runs per collider per step.
+     *
+     * @param {AbstractShape3D} shape
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     */
+    setup_components(shape, px, py, pz, qx, qy, qz, qw) {
         this.shape = shape;
-        this.px = position.x; this.py = position.y; this.pz = position.z;
-        this.qx = rotation.x; this.qy = rotation.y; this.qz = rotation.z; this.qw = rotation.w;
+        this.px = px; this.py = py; this.pz = pz;
+        this.qx = qx; this.qy = qy; this.qz = qz; this.qw = qw;
     }
 
     /**

package/src/core/graph/format/graphviz/graphviz_escape_html_label.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Escapes a string for use inside a GraphViz **HTML-like** label, that is `label=<...>` rather than
+ * `label="..."`.
+ *
+ * The two label syntaxes have nothing in common. Inside `<...>` the text is parsed as markup, so a
+ * bare `&`, `<` or `>` is a syntax error that makes graphviz refuse **the whole file** rather than
+ * the one node — which is exactly when a pass gets named something descriptive. And the
+ * backslash escapes {@link graphviz_escape_string} produces are not processed there at all: they
+ * render as literal backslashes.
+ *
+ * @param {string} input The raw string to be escaped.
+ * @returns {string} The escaped string, safe to interpolate into an HTML-like label.
+ * @see graphviz_escape_string for the `label="..."` / quoted-attribute case
+ * @see https://graphviz.org/doc/info/shapes.html#html
+ */
+export function graphviz_escape_html_label(input: string): string;
+//# sourceMappingURL=graphviz_escape_html_label.d.ts.map

package/src/core/graph/format/graphviz/graphviz_escape_html_label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphviz_escape_html_label.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/format/graphviz/graphviz_escape_html_label.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,kDALW,MAAM,GACJ,MAAM,CAWlB"}

package/src/core/graph/format/graphviz/graphviz_escape_html_label.js

@@ -0,0 +1,25 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Escapes a string for use inside a GraphViz **HTML-like** label, that is `label=<...>` rather than
+ * `label="..."`.
+ *
+ * The two label syntaxes have nothing in common. Inside `<...>` the text is parsed as markup, so a
+ * bare `&`, `<` or `>` is a syntax error that makes graphviz refuse **the whole file** rather than
+ * the one node — which is exactly when a pass gets named something descriptive. And the
+ * backslash escapes {@link graphviz_escape_string} produces are not processed there at all: they
+ * render as literal backslashes.
+ *
+ * @param {string} input The raw string to be escaped.
+ * @returns {string} The escaped string, safe to interpolate into an HTML-like label.
+ * @see graphviz_escape_string for the `label="..."` / quoted-attribute case
+ * @see https://graphviz.org/doc/info/shapes.html#html
+ */
+export function graphviz_escape_html_label(input) {
+    assert.isString(input, 'input');
+
+    return input
+        .replace(/&/g, '&amp;')  // first, or it would escape the ampersands introduced below
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/src/core/graph/format/graphviz/graphviz_escape_quoted.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Escapes a string for use inside a plain **quoted attribute**, such as `tooltip="..."` or a
+ * cluster's `label="..."` — anywhere the value is text rather than a record label.
+ *
+ * Only the two characters that would end or corrupt the quoted string, plus newlines.
+ * {@link graphviz_escape_string} additionally backslash-escapes `|`, `{` and `}`, which is right
+ * for `shape=record` label syntax and wrong everywhere else: in an ordinary attribute those are
+ * ordinary characters, and the escapes are rendered as literal backslashes.
+ *
+ * @param {string} input The raw string to be escaped.
+ * @returns {string} The escaped string, safe to sit inside double quotes.
+ * @see graphviz_escape_string for the record-label case
+ * @see https://graphviz.org/docs/attr-types/escString/
+ */
+export function graphviz_escape_quoted(input: string): string;
+//# sourceMappingURL=graphviz_escape_quoted.d.ts.map

package/src/core/graph/format/graphviz/graphviz_escape_quoted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphviz_escape_quoted.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/format/graphviz/graphviz_escape_quoted.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,8CALW,MAAM,GACJ,MAAM,CAWlB"}

package/src/core/graph/format/graphviz/graphviz_escape_quoted.js

@@ -0,0 +1,24 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Escapes a string for use inside a plain **quoted attribute**, such as `tooltip="..."` or a
+ * cluster's `label="..."` — anywhere the value is text rather than a record label.
+ *
+ * Only the two characters that would end or corrupt the quoted string, plus newlines.
+ * {@link graphviz_escape_string} additionally backslash-escapes `|`, `{` and `}`, which is right
+ * for `shape=record` label syntax and wrong everywhere else: in an ordinary attribute those are
+ * ordinary characters, and the escapes are rendered as literal backslashes.
+ *
+ * @param {string} input The raw string to be escaped.
+ * @returns {string} The escaped string, safe to sit inside double quotes.
+ * @see graphviz_escape_string for the record-label case
+ * @see https://graphviz.org/docs/attr-types/escString/
+ */
+export function graphviz_escape_quoted(input) {
+    assert.isString(input, 'input');
+
+    return input
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n');
+}

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

@@ -43,6 +43,18 @@ export class NodeGraph {
      */
     readonly get version(): number;
     /**
+     * Changes to the graph's structure, announced once the graph is consistent again.
+     *
+     * A connection is not one fact but three — an entry in {@link #connections}, and a link on each
+     * of the two endpoints it joins — and everything that asks what is wired to a port reads the
+     * endpoint links rather than the list. These signals are the list's own, so the endpoint links
+     * are written before a connection joins the list and erased before it leaves: a listener always
+     * sees a whole edit rather than the middle of one.
+     *
+     * Without that, a validator run from `connectionRemoved` would still find the wire that was
+     * just cut, and one run from `connectionAdded` would not find the wire that was just made — so
+     * every diagnostic in the editor would describe the graph as it was one edit ago.
+     *
      * @readonly
      */
     readonly on: {

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;;;;;OAKG;IACH,+BAEC;IAED;;OAEG;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;;;;;;;;OAQG;IACH,sCAJW,YAAY,EAAE,GAEZ;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,CAuDlB;IAED;;;;;;;OAOG;IACH,0BAHW,UAAU,GACR,MAAM,CA2BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,OAAO,CA4BnB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,UACN,MAAM,EAAE,GACN,MAAM,CAyBlB;IAED,mBAEC;IAGL;;;;;;;;OAQG;IACH,sBAFU,OAAO,CAEc;;CAX9B;6BAhtB4B,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;;;;;OAKG;IACH,+BAEC;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;;;;;;;;OAQG;IACH,sCAJW,YAAY,EAAE,GAEZ;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"}

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

@@ -66,6 +66,18 @@ export class NodeGraph {
     }
 
     /**
+     * Changes to the graph's structure, announced once the graph is consistent again.
+     *
+     * A connection is not one fact but three — an entry in {@link #connections}, and a link on each
+     * of the two endpoints it joins — and everything that asks what is wired to a port reads the
+     * endpoint links rather than the list. These signals are the list's own, so the endpoint links
+     * are written before a connection joins the list and erased before it leaves: a listener always
+     * sees a whole edit rather than the middle of one.
+     *
+     * Without that, a validator run from `connectionRemoved` would still find the wire that was
+     * just cut, and one run from `connectionAdded` would not find the wire that was just made — so
+     * every diagnostic in the editor would describe the graph as it was one edit ago.
+     *
      * @readonly
      */
     on = {
@@ -608,8 +620,6 @@ export class NodeGraph {
         const id = this.__idpConnections.get();
         connection.id = id;
 
-        this.connections.add(connection);
-
         // add connection links to the nodes
         sourceNodeInstance.connections.addUnique(connection);
         targetNodeInstance.connections.addUnique(connection);
@@ -617,6 +627,9 @@ export class NodeGraph {
         array_push_if_unique(sourceEndpoint.connections, connection);
         array_push_if_unique(targetEndpoint.connections, connection);
 
+        // last, because this is what announces the addition: see the note on #on
+        this.connections.add(connection);
+
         this.#version++;
 
         return id;
@@ -643,8 +656,6 @@ export class NodeGraph {
         const sourceEndpoint = connection.source;
         const targetEndpoint = connection.target;
 
-        this.connections.add(connection);
-
         // add connection links to the nodes
         sourceEndpoint.instance.connections.addUnique(connection);
         targetEndpoint.instance.connections.addUnique(connection);
@@ -652,6 +663,9 @@ export class NodeGraph {
         array_push_if_unique(sourceEndpoint.connections, connection);
         array_push_if_unique(targetEndpoint.connections, connection);
 
+        // last, because this is what announces the addition: see the note on #on
+        this.connections.add(connection);
+
         this.#version++;
 
         return connection.id;
@@ -670,8 +684,6 @@ export class NodeGraph {
             return false;
         }
 
-        this.connections.removeOneOf(connection);
-
         // remove from end-point nodes
         const sourceEndpoint = connection.source;
         const targetEndpoint = connection.target;
@@ -682,6 +694,9 @@ export class NodeGraph {
         array_remove_first(sourceEndpoint.connections, connection);
         array_remove_first(targetEndpoint.connections, connection);
 
+        // last, because this is what announces the removal: see the note on #on
+        this.connections.removeOneOf(connection);
+
         //release id, mirroring deleteNode
         this.__idpConnections.release(id);
 

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

@@ -11,6 +11,32 @@ export class NodeDescription {
      * @type {string}
      */
     name: string;
+    /**
+     * What to call this node type in front of a person, where that is not what {@link #name} is.
+     *
+     * A library's names are addresses: they are what a graph serializes, what code looks a type up
+     * by, and so they are terse and they do not change. `div`, `mad`, `setAttribute`. None of those
+     * is what an author reads them as, and a graph that only ever shows them makes every reader
+     * translate — so a view shows this and the model keeps the name.
+     *
+     * Empty means the name is already what to show, which is the honest answer for a type called
+     * `clamp`. Read it through {@link #getDisplayLabel} rather than directly.
+     *
+     * @type {string}
+     */
+    display_label: string;
+    /**
+     * A glyph for this node type: SVG path data drawn in a 24x24 box, or an empty string for a type
+     * with no icon.
+     *
+     * Path data rather than an image because an icon here is small, is drawn at several sizes, and
+     * has to take the colour of whatever it is sitting in — and because a library of node types
+     * that ships as source has nowhere to put a hundred PNGs. `stroke` and `currentColor` are the
+     * view's business; this is the shape.
+     *
+     * @type {string}
+     */
+    icon: string;
     /**
      * A unique identifier in the scope of a single registry
      * If two nodes belong to the same registry - they must have different IDs
@@ -44,6 +70,16 @@ export class NodeDescription {
          */
         readonly portRemoved: any;
     };
+    /**
+     * What to show a person for this node type: {@link #display_label} where there is one, and
+     * {@link #name} otherwise.
+     *
+     * The one place the fallback lives, so every view that puts a node type in front of somebody —
+     * the node itself, a palette, a search result, a diagnostic — agrees on what it is called.
+     *
+     * @returns {string}
+     */
+    getDisplayLabel(): string;
     /**
      * Perform additional processing on the node instance
      * This gives us an opportunity to add/change ports based on current state of a specific node instance

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

@@ -1 +1 @@
-{"version":3,"file":"NodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeDescription.js"],"names":[],"mappings":"AAwCA;IAsXI;;;;;OAKG;IACH,iDAFa,eAAe,CAQ3B;IAjYD;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAEL;IAEX;;;OAGG;IACH,YAFU,wBAAwB,EAAE,CAEpB;IAEhB;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,sBALW,MAAM,QACN,qBAAqB,iBACrB,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,MAAM,CA0ClB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAiBzC;IAGD;;;;;;OAMG;IACH,oDAHW,aAAa,GACX,MAAM,CA2BlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAuBnB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAgBrB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,EAAE,CAwBjB;IAED;;;;;OAKG;IACH,+BAHW,aAAa,GACZ,OAAO,CAiBlB;IAED;;;;OAIG;IACH,+BAHW,aAAa,GACZ,IAAI,EAAE,CAuBjB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,aACN,aAAa,GACZ,IAAI,GAAC,SAAS,CAmBzB;IAED;;;OAGG;IACH,YAFa,IAAI,EAAE,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAYnB;IAED,mBAEC;IAED;;;;MAMC;IAgBD;;;;;;OAMG;IACH,8BALW,EAAE,gCAaZ;IAKL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAR1C;;;;qBArboB,WAAW;yCADS,yCAAyC;sCAD5C,sCAAsC;8BAG9C,oBAAoB"}
+{"version":3,"file":"NodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeDescription.js"],"names":[],"mappings":"AAwCA;IA+ZI;;;;;OAKG;IACH,iDAFa,eAAe,CAQ3B;IA1aD;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;;;;;;OAYG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;;;;;;OAUG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAEL;IAEX;;;OAGG;IACH,YAFU,wBAAwB,EAAE,CAEpB;IAEhB;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;;OAQG;IACH,mBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,sBALW,MAAM,QACN,qBAAqB,iBACrB,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,MAAM,CA0ClB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAiBzC;IAGD;;;;;;OAMG;IACH,oDAHW,aAAa,GACX,MAAM,CA2BlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAuBnB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAgBrB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,EAAE,CAwBjB;IAED;;;;;OAKG;IACH,+BAHW,aAAa,GACZ,OAAO,CAiBlB;IAED;;;;OAIG;IACH,+BAHW,aAAa,GACZ,IAAI,EAAE,CAuBjB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,aACN,aAAa,GACZ,IAAI,GAAC,SAAS,CAmBzB;IAED;;;OAGG;IACH,YAFa,IAAI,EAAE,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAYnB;IAED,mBAEC;IAED;;;;MAMC;IAgBD;;;;;;OAMG;IACH,8BALW,EAAE,gCAaZ;IAKL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAR1C;;;;qBA9doB,WAAW;yCADS,yCAAyC;sCAD5C,sCAAsC;8BAG9C,oBAAoB"}

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

@@ -45,6 +45,34 @@ export class NodeDescription {
      */
     name = "";
 
+    /**
+     * What to call this node type in front of a person, where that is not what {@link #name} is.
+     *
+     * A library's names are addresses: they are what a graph serializes, what code looks a type up
+     * by, and so they are terse and they do not change. `div`, `mad`, `setAttribute`. None of those
+     * is what an author reads them as, and a graph that only ever shows them makes every reader
+     * translate — so a view shows this and the model keeps the name.
+     *
+     * Empty means the name is already what to show, which is the honest answer for a type called
+     * `clamp`. Read it through {@link #getDisplayLabel} rather than directly.
+     *
+     * @type {string}
+     */
+    display_label = "";
+
+    /**
+     * A glyph for this node type: SVG path data drawn in a 24x24 box, or an empty string for a type
+     * with no icon.
+     *
+     * Path data rather than an image because an icon here is small, is drawn at several sizes, and
+     * has to take the colour of whatever it is sitting in — and because a library of node types
+     * that ships as source has nowhere to put a hundred PNGs. `stroke` and `currentColor` are the
+     * view's business; this is the shape.
+     *
+     * @type {string}
+     */
+    icon = "";
+
     /**
      * A unique identifier in the scope of a single registry
      * If two nodes belong to the same registry - they must have different IDs
@@ -82,6 +110,19 @@ export class NodeDescription {
         portRemoved: new Signal()
     };
 
+    /**
+     * What to show a person for this node type: {@link #display_label} where there is one, and
+     * {@link #name} otherwise.
+     *
+     * The one place the fallback lives, so every view that puts a node type in front of somebody —
+     * the node itself, a palette, a search result, a diagnostic — agrees on what it is called.
+     *
+     * @returns {string}
+     */
+    getDisplayLabel() {
+        return this.display_label !== "" ? this.display_label : this.name;
+    }
+
     /**
      * Perform additional processing on the node instance
      * This gives us an opportunity to add/change ports based on current state of a specific node instance

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

@@ -0,0 +1,119 @@
+/**
+ * The path one connection is drawn along.
+ *
+ * A chain of cubic Hermite curves, joined end to end: each knot is a point and the tangent the curve
+ * passes through it with, and each pair of neighbouring knots is one curve. A wire that goes
+ * straight from one port to another is two knots and looks like what it always did; one that had to
+ * find its way around three nodes is a dozen, and the corners between its straight runs are the
+ * curves.
+ *
+ * **Hermite rather than Bézier** because the two ends of a curve are what everything here is stated
+ * in terms of — a wire leaves a port in a direction, meets a corner at a tangent, and shares both
+ * with whatever is on the other side of the knot. Bézier control points are the same information
+ * said less directly, and conversion is exact and one multiply away for the drawing code that wants
+ * them.
+ *
+ * Everything is held in one flat array rather than as objects per knot: a graph has hundreds of
+ * these, all of them are read on every repaint, and none of them is ever handled one knot at a time.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ConnectionVisualData {
+    /**
+     * Id of the connection this is the path of.
+     * @type {number}
+     */
+    id: number;
+    /**
+     * `[x, y, tangent x, tangent y]` per knot.
+     * @type {Float64Array}
+     */
+    knots: Float64Array;
+    /**
+     * @type {number}
+     */
+    knot_count: number;
+    /**
+     * @returns {number}
+     */
+    get segment_count(): number;
+    /**
+     * Make room for a path of the given size, discarding whatever was here.
+     * @param {number} knot_count
+     * @returns {void}
+     */
+    allocate(knot_count: number): void;
+    /**
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} tangent_x
+     * @param {number} tangent_y
+     * @returns {void}
+     */
+    set_knot(index: number, x: number, y: number, tangent_x: number, tangent_y: number): void;
+    /**
+     * A point along the path.
+     *
+     * `t` runs from 0 at the source port to 1 at the target, split evenly between the segments
+     * rather than by their length — the segments are not the same length, so this walks the path
+     * unevenly. That is what a caller drawing or hit-testing wants anyway, since a corner is short
+     * and needs as many samples as a long straight run.
+     *
+     * @param {Vector2} result
+     * @param {number} t in [0, 1]
+     * @returns {void}
+     */
+    sample(result: Vector2, t: number): void;
+    /**
+     * @param {Vector2} result
+     * @param {number} segment
+     * @param {number} t in [0, 1]
+     * @returns {void}
+     */
+    sample_segment(result: Vector2, segment: number, t: number): void;
+    /**
+     * Control points of one segment, as a cubic Bézier.
+     * @param {number[]|Float64Array} result 8 numbers written: `[x0, y0, cx0, cy0, cx1, cy1, x1, y1]`
+     * @param {number} offset
+     * @param {number} segment
+     * @returns {void}
+     */
+    write_segment_bezier(result: number[] | Float64Array, offset: number, segment: number): void;
+    /**
+     * Exact bounds of the whole path.
+     *
+     * Exact rather than the bounds of the knots: a curve leaves the line between its ends, and a
+     * caller culling by these would drop a wire whose bulge is the only part on screen.
+     *
+     * @param {AABB2} result set, not expanded
+     * @returns {void}
+     */
+    computeBounds(result: AABB2): void;
+    /**
+     * Distance from a point to the path, by flattening it.
+     *
+     * Precision is ample for deciding what a click landed on, which is the only thing that asks.
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    distanceToPoint(x: number, y: number): number;
+    /**
+     * @param {ConnectionVisualData} other
+     * @returns {void}
+     */
+    copy(other: ConnectionVisualData): void;
+    /**
+     * @returns {ConnectionVisualData}
+     */
+    clone(): ConnectionVisualData;
+    toJSON(): {
+        id: number;
+        knots: any[];
+    };
+    fromJSON(json: any): void;
+}
+//# sourceMappingURL=ConnectionVisualData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionVisualData.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/visual/ConnectionVisualData.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,OAFU,YAAY,CAEM;IAE5B;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;OAEG;IACH,4BAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;;;OAOG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,aACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;;;;;;;OAWG;IACH,2BAHW,MAAM,GACJ,IAAI,CA4BhB;IAED;;;;;OAKG;IACH,yCAJW,MAAM,KACN,MAAM,GACJ,IAAI,CAYhB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,WACN,MAAM,GACJ,IAAI,CAUhB;IAED;;;;;;;;OAQG;IACH,8BAFa,IAAI,CA8BhB;IAED;;;;;;;;OAQG;IACH,mBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CA2ClB;IAED;;;OAGG;IACH,YAHW,oBAAoB,GAClB,IAAI,CAQhB;IAED;;OAEG;IACH,SAFa,oBAAoB,CAQhC;IAED;;;MAWC;IAED,0BAUC;CACJ"}