@rosepetal/node-red-contrib-utils 1.1.1

package/nodes/io/array-in.js

@@ -0,0 +1,113 @@
+/**
+ * @file Node.js logic for the Array-In node with input path and array position.
+ * @author Rosepetal
+ */
+
+module.exports = function(RED) {
+  const NodeUtils = require('../../lib/node-utils.js')(RED);
+  
+  function ArrayInNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    
+    // Store configuration with validation
+    node.inputPath = config.inputPath || 'payload';
+    node.inputPathType = config.inputPathType || 'msg';
+    
+    // Dynamic position configuration
+    node.arrayPositionType = config.arrayPositionType || 'num';
+    node.arrayPositionValue = config.arrayPositionValue !== undefined ? config.arrayPositionValue : 0;
+
+    // Set initial status
+    const statusText = node.arrayPositionType === 'num' 
+      ? `Position: ${node.arrayPositionValue}` 
+      : `Position: ${node.arrayPositionType}.${node.arrayPositionValue}`;
+    node.status({ 
+      fill: "blue", 
+      shape: "dot", 
+      text: statusText
+    });
+
+    // Handle incoming messages
+    node.on('input', function(msg, send, done) {
+      try {
+        // Resolve array position dynamically
+        let resolvedPosition;
+        try {
+          resolvedPosition = NodeUtils.resolveArrayPosition(
+            node, 
+            node.arrayPositionType, 
+            node.arrayPositionValue, 
+            msg
+          );
+        } catch (err) {
+          node.warn(`Failed to resolve array position: ${err.message}`);
+          node.status({ fill: "red", shape: "ring", text: "Invalid position" });
+          return done ? done() : null;
+        }
+
+        // Get data from configured input path
+        let arrayData;
+        if (node.inputPathType === 'msg') {
+          arrayData = RED.util.getMessageProperty(msg, node.inputPath);
+        } else if (node.inputPathType === 'flow') {
+          arrayData = node.context().flow.get(node.inputPath);
+        } else if (node.inputPathType === 'global') {
+          arrayData = node.context().global.get(node.inputPath);
+        }
+
+        // Handle undefined data gracefully
+        if (arrayData === undefined) {
+          node.warn(`No data found at ${node.inputPathType}.${node.inputPath}`);
+          arrayData = null;
+        }
+
+        // Initialize msg.meta if it doesn't exist
+        if (!msg.meta) {
+          msg.meta = {};
+        }
+
+        // Add array metadata and optionally mirror into payload
+        msg.meta.arrayPosition = resolvedPosition;
+        msg.meta.arrayData = arrayData;
+
+        const normalizedPath = typeof node.inputPath === 'string'
+          ? node.inputPath.trim()
+          : node.inputPath;
+        const shouldMirrorPayload =
+          node.inputPathType === 'msg' &&
+          normalizedPath === 'payload';
+
+        if (shouldMirrorPayload) {
+          msg.payload = arrayData;
+        }
+
+        // Update status
+        node.status({ 
+          fill: "green", 
+          shape: "dot", 
+          text: `Position: ${resolvedPosition}` 
+        });
+
+        // Send the message with array metadata
+        send(msg);
+        if (done) { done(); }
+
+      } catch (err) {
+        node.status({ fill: "red", shape: "ring", text: "Error" });
+        if (done) {
+          done(err);
+        } else {
+          node.error(err, msg);
+        }
+      }
+    });
+
+    // Clean up on node removal
+    node.on('close', function() {
+      node.status({});
+    });
+  }
+
+  RED.nodes.registerType("rp-array-in", ArrayInNode);
+};

package/nodes/io/array-out.html

@@ -0,0 +1,125 @@
+<script type="text/javascript">
+    RED.nodes.registerType('rp-array-out', {
+        category: 'RP Utils',
+        color: '#87CEEB',
+        defaults: {
+            name: { value: "" },
+            timeout: { value: 5000 },
+            expectedCount: { value: 2, required: true, validate: RED.validators.number() },
+            outputPath: { value: "payload" },
+            outputPathType: { value: "msg" }
+        },
+        inputs: 1,
+        outputs: 2,
+        icon: "font-awesome/fa-sign-out",
+        label: function() {
+            return this.name || `Array Out (${this.expectedCount} items)`;
+        },
+        oneditprepare: function() {
+            // Set up TypedInput for output path
+            $("#node-input-outputPath").typedInput({
+                default: 'msg',
+                types: ['msg', 'flow', 'global'],
+                typeField: "#node-input-outputPathType"
+            });
+        }
+    });
+</script>
+
+<script type="text/x-red" data-template-name="rp-array-out">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    
+    <hr>
+    
+    <div class="form-row">
+        <label for="node-input-timeout"><i class="fa fa-clock-o"></i> Timeout (ms)</label>
+        <input type="number" id="node-input-timeout" min="100" step="100" style="width: 70%;" placeholder="5000">
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-expectedCount"><i class="fa fa-hashtag"></i> Expected Count</label>
+        <input type="number" id="node-input-expectedCount" min="1" step="1" style="width: 70%;" placeholder="2" required>
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-outputPath"><i class="fa fa-sign-out"></i> Output to</label>
+        <input type="text" id="node-input-outputPath" style="width: 70%;">
+        <input type="hidden" id="node-input-outputPathType">
+    </div>
+    
+    <div class="form-tips">
+        <b>Timeout:</b> Maximum time to wait for all array elements after the first message arrives. If timeout occurs, collected data and missing position info are sent to output 2.<br>
+        <b>Expected Count:</b> Number of array elements required before outputting the assembled array.
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="rp-array-out">
+    <p>Collects messages from multiple rp-array-in nodes and assembles them into an ordered array based on position indices.</p>
+    
+    <h3>Details</h3>
+    <p>This node works as the collection point for multiple rp-array-in nodes. It waits for messages containing array metadata, collects them based on their position indices, and outputs a complete array when all expected elements are received. The node includes timeout protection and performance monitoring.</p>
+    
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Timeout <span class="property-type">number</span></dt>
+        <dd>Maximum time in milliseconds to wait for all array elements after the first message arrives. Default: 5000ms. If timeout occurs, collected data and missing position info are sent to output 2.</dd>
+        <dt>Expected Count <span class="property-type">number</span></dt>
+        <dd>Number of array elements required before outputting the assembled array. Must match the number of rp-array-in nodes connected. Required field, minimum value: 1.</dd>
+        <dt>Output to <span class="property-type">string</span></dt>
+        <dd>The location where the assembled array will be stored. You can select between <code>msg</code>, <code>flow</code>, or <code>global</code> context. Defaults to <code>msg.payload</code>.</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">any</span></dt>
+        <dd>Messages from rp-array-in nodes containing array metadata.</dd>
+        <dt>meta.arrayPosition <span class="property-type">number</span></dt>
+        <dd>The array position index (0, 1, 2...) provided by rp-array-in nodes.</dd>
+        <dt>meta.arrayData <span class="property-type">any</span></dt>
+        <dd>The actual data to be placed in the array at the specified position.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>Output 1 - Complete Array <span class="property-type">array</span></dt>
+        <dd>The complete assembled array when all expected elements are received: [data0, data1, data2...]</dd>
+        <dt>Output 2 - Timeout Data <span class="property-type">object</span></dt>
+        <dd>On timeout: collected data array (with nulls for missing) plus metadata about missing positions</dd>
+    </dl>
+
+    <h3>Operation Flow</h3>
+    <ol>
+        <li><strong>First Message:</strong> Starts timeout timer and begins collection</li>
+        <li><strong>Collection:</strong> Gathers messages from rp-array-in nodes, validates positions</li>
+        <li><strong>Assembly:</strong> Places data at specified array positions based on meta.arrayPosition</li>
+        <li><strong>Success:</strong> Outputs assembled array when all expected elements received</li>
+        <li><strong>Timeout:</strong> Sends collected data + missing info to output 2</li>
+        <li><strong>Reset:</strong> Ready for next collection cycle</li>
+    </ol>
+
+    <h3>Examples</h3>
+    <ul>
+        <li><strong>Basic Array Assembly:</strong> With Expected Count = 3, rp-array-in nodes at positions 0, 1, 2 will produce: <code>["data0", "data1", "data2"]</code></li>
+        <li><strong>Image Array:</strong> Three image-in → rp-array-in (positions 0,1,2) → rp-array-out → creates array of image objects for batch processing</li>
+        <li><strong>Mixed Data:</strong> Combine different data types from various sources into a single ordered array</li>
+    </ul>
+
+    <h3>Node Interactions</h3>
+    <p><strong>Requires:</strong> Multiple rp-array-in nodes, each with unique position indices (0, 1, 2...)</p>
+    <p><strong>Works with:</strong> Transform nodes that support array inputs (resize, rotate, etc.), rp-array-select for element extraction</p>
+    <p><strong>Best Practice:</strong> Set Expected Count to match the number of rp-array-in nodes. Use reasonable timeout values based on your processing requirements.</p>
+
+    <h3>Error Handling</h3>
+    <p>The node handles various error conditions:</p>
+    <ul>
+        <li><strong>Missing metadata:</strong> Messages without proper array metadata are ignored</li>
+        <li><strong>Duplicate positions:</strong> Later messages overwrite earlier ones at the same position</li>
+        <li><strong>Timeout:</strong> Collection resets, node status shows timeout, no output sent</li>
+    </ul>
+
+    <h3>Performance</h3>
+    <p>Node status displays collection timing when successful. The timeout mechanism prevents indefinite waiting for missing array elements.</p>
+</script>

package/nodes/io/array-out.js

@@ -0,0 +1,213 @@
+/**
+ * @file Node.js logic for the Array‑Out node with timeout, ordering and validation.
+ * @author Rosepetal
+ */
+
+module.exports = function (RED) {
+  function ArrayOutNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    /* ────────────────────────────
+       ░░ 1.  Read & validate cfg ░░
+       ──────────────────────────── */
+    node.timeout       = parseInt(config.timeout) || 5000;
+    node.expectedCount = parseInt(config.expectedCount);
+    node.outputPath    = config.outputPath || 'payload';
+    node.outputPathType = config.outputPathType || 'msg';
+
+    if (!Number.isInteger(node.expectedCount) || node.expectedCount < 1) {
+      node.error('Invalid expectedCount. Must be a positive integer.');
+      node.expectedCount = 2; // sensible default
+    }
+
+    /* ────────────────────────────
+       ░░ 2.  Internal state      ░░
+       ──────────────────────────── */
+    node.collection          = {};
+    node.timeoutHandle       = null;
+    node.isCollecting        = false;
+    node.collectionStartTime = null;
+
+    setStatusReady();
+
+    /* ────────────────────────────
+       ░░ 3.  Helper functions   ░░
+       ──────────────────────────── */
+    function setStatusReady() {
+      node.status({
+        fill: 'blue',
+        shape: 'dot',
+        text: `Ready (expect ${node.expectedCount})`
+      });
+    }
+
+    function resetCollection() {
+      if (node.timeoutHandle) {
+        clearTimeout(node.timeoutHandle);
+        node.timeoutHandle = null;
+      }
+      node.collection          = {};
+      node.isCollecting        = false;
+      node.collectionStartTime = null;
+    }
+
+    function handleTimeout() {
+      const elapsed = Date.now() - node.collectionStartTime;
+      
+      /* Build timeout message with collected data + missing info */
+      const collectedPositions = Object.keys(node.collection).map(k => parseInt(k)).sort((a, b) => a - b);
+      const missingPositions = [];
+      for (let i = 0; i < node.expectedCount; i++) {
+        if (!node.collection.hasOwnProperty(i)) {
+          missingPositions.push(i);
+        }
+      }
+      
+      /* Build the partial array (same logic as normal completion) */
+      const result = Array.from({ length: node.expectedCount }, (_, i) =>
+        node.collection.hasOwnProperty(i) ? node.collection[i] : null
+      );
+      
+      /* Create timeout message */
+      const timeoutMsg = {
+        meta: {
+          timeout: true,
+          missingPositions: missingPositions,
+          collectedPositions: collectedPositions,
+          expectedCount: node.expectedCount,
+          collectedCount: collectedPositions.length,
+          elapsed: elapsed
+        }
+      };
+      
+      /* Place the partial array where the user wants it */
+      if (node.outputPathType === 'msg') {
+        RED.util.setMessageProperty(timeoutMsg, node.outputPath, result, true);
+      } else if (node.outputPathType === 'flow') {
+        node.context().flow.set(node.outputPath, result);
+      } else if (node.outputPathType === 'global') {
+        node.context().global.set(node.outputPath, result);
+      }
+      
+      /* Send to output 2 only */
+      node.send([null, timeoutMsg]);
+      
+      node.status({
+        fill: 'yellow',
+        shape: 'ring',
+        text: `Timeout: sent ${collectedPositions.length}/${node.expectedCount} to output 2`
+      });
+      
+      resetCollection();
+      setTimeout(setStatusReady, 3000);
+    }
+
+    function assembleAndOutput(sourceMsg) {
+      const elapsed = Date.now() - node.collectionStartTime;
+
+      /* Build the ordered array (fill gaps with null) */
+      const result = Array.from({ length: node.expectedCount }, (_, i) =>
+        node.collection.hasOwnProperty(i) ? node.collection[i] : null
+      );
+
+      /* Place the array where the user wants it */
+      const outMsg = { ...sourceMsg }; // shallow‑clone to keep headers etc.
+      if (node.outputPathType === 'msg') {
+        RED.util.setMessageProperty(outMsg, node.outputPath, result, true);
+      } else if (node.outputPathType === 'flow') {
+        node.context().flow.set(node.outputPath, result);
+      } else if (node.outputPathType === 'global') {
+        node.context().global.set(node.outputPath, result);
+      }
+
+      node.status({
+        fill: 'green',
+        shape: 'dot',
+        text: `Complete: ${result.length} (${elapsed} ms)`
+      });
+      node.send([outMsg, null]);
+
+      /* Return to ready after a short pause */
+      setTimeout(setStatusReady, 2000);
+      resetCollection();
+    }
+
+    /* ────────────────────────────
+       ░░ 4.  Input handler      ░░
+       ──────────────────────────── */
+    node.on('input', function (msg, send, done) {
+      try {
+        /* 4.1  Basic sanity checks */
+        if (!msg.meta || typeof msg.meta.arrayPosition !== 'number') {
+          node.warn(
+            'Message missing array metadata. Expected msg.meta.arrayPosition (number) from rp-array-in node'
+          );
+          return done?.();
+        }
+
+        const position = msg.meta.arrayPosition;
+
+        /* 4.2  Validate range */
+        if (position < 0 || position >= node.expectedCount) {
+          node.warn(
+            `Position ${position} out of range 0‑${node.expectedCount - 1}`
+          );
+          return done?.();
+        }
+
+        /* 4.3  Extract data – prefer meta.arrayData, fall back to payload */
+        const data =
+          msg.meta && msg.meta.arrayData !== undefined
+            ? msg.meta.arrayData
+            : msg.payload;
+
+        /* 4.4  Start collection if first element */
+        if (!node.isCollecting) {
+          node.isCollecting        = true;
+          node.collection          = {};
+          node.collectionStartTime = Date.now();
+          node.timeoutHandle       = setTimeout(handleTimeout, node.timeout);
+          node.status({
+            fill: 'yellow',
+            shape: 'dot',
+            text: 'Collecting… (1/' + node.expectedCount + ')'
+          });
+        }
+
+        /* 4.5  Store element */
+        node.collection[position] = data;
+
+        /* 4.6  Update collecting status */
+        const collected = Object.keys(node.collection).length;
+        node.status({
+          fill: 'yellow',
+          shape: 'dot',
+          text: `Collecting… (${collected}/${node.expectedCount})`
+        });
+
+        /* 4.7  Check completion */
+        if (collected === node.expectedCount) {
+          assembleAndOutput(msg);
+        }
+
+        done?.();
+      } catch (err) {
+        node.status({ fill: 'red', shape: 'ring', text: 'Error' });
+        resetCollection();
+        if (done) done(err);
+        else node.error(err, msg);
+      }
+    });
+
+    /* ────────────────────────────
+       ░░ 5.  Cleanup            ░░
+       ──────────────────────────── */
+    node.on('close', function () {
+      resetCollection();
+      node.status({});
+    });
+  }
+
+  RED.nodes.registerType('rp-array-out', ArrayOutNode);
+};

package/nodes/io/array-select.html

@@ -0,0 +1,156 @@
+<script type="text/javascript">
+    RED.nodes.registerType('rp-array-select', {
+        category: 'RP Utils',
+        color: '#7b8dff',
+        defaults: {
+            name: { value: "" },
+            inputPath: { value: "payload" },
+            inputPathType: { value: "msg" },
+            outputPath: { value: "payload" },
+            outputPathType: { value: "msg" },
+            selection: { value: "0" },
+            asArray: { value: false }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-columns",
+        label: function() {
+            if (this.name) return this.name;
+            return `Array Select [${this.selection}]`;
+        },
+        oneditprepare: function() {
+            // Set up TypedInput for input path
+            $("#node-input-inputPath").typedInput({
+                default: 'msg',
+                types: ['msg', 'flow', 'global'],
+                typeField: "#node-input-inputPathType"
+            });
+            
+            // Set up TypedInput for output path
+            $("#node-input-outputPath").typedInput({
+                default: 'msg',
+                types: ['msg', 'flow', 'global'],
+                typeField: "#node-input-outputPathType"
+            });
+        }
+    });
+</script>
+
+<script type="text/x-red" data-template-name="rp-array-select">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    
+    <hr>
+    
+    <div class="form-row">
+        <label for="node-input-inputPath"><i class="fa fa-sign-in"></i> Input from</label>
+        <input type="text" id="node-input-inputPath" style="width: 70%;">
+        <input type="hidden" id="node-input-inputPathType">
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-outputPath"><i class="fa fa-sign-out"></i> Output to</label>
+        <input type="text" id="node-input-outputPath" style="width: 70%;">
+        <input type="hidden" id="node-input-outputPathType">
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-selection"><i class="fa fa-filter"></i> Selection</label>
+        <input type="text" id="node-input-selection" style="width: 70%;" placeholder="e.g., 0, 1,3,5, 1:4, 0::2">
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-asArray"><i class="fa fa-list"></i> Force Array</label>
+        <input type="checkbox" id="node-input-asArray">
+        <span style="margin-left: 5px;">Always output as array (even for single items)</span>
+    </div>
+    
+    <div class="form-tips">
+        <b>Selection Examples:</b><br>
+        • <code>0</code> - First element<br>
+        • <code>1,3,5</code> - Elements at indices 1, 3, 5<br>
+        • <code>1:4</code> - Elements 1 to 3 (range)<br>
+        • <code>0::2</code> - Every 2nd element starting from 0<br>
+        • <code>-1</code> - Last element<br>
+        • <code>-2:-1</code> - Last two elements
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="rp-array-select">
+    <p>Selects specific elements from an input array using flexible selection syntax including indices, ranges, and patterns.</p>
+    
+    <h3>Details</h3>
+    <p>This node provides powerful array element selection capabilities with Python-like slicing syntax. It can extract single elements, multiple specific indices, ranges, or patterns from arrays. The output format is automatically determined based on the selection size, with an option to force array output.</p>
+    
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Input from <span class="property-type">string</span></dt>
+        <dd>The location to read the input array from. You can select between <code>msg</code>, <code>flow</code>, or <code>global</code> context. Defaults to <code>msg.payload</code>.</dd>
+        <dt>Output to <span class="property-type">string</span></dt>
+        <dd>The location where to write the selected element(s). You can select between <code>msg</code>, <code>flow</code>, or <code>global</code> context. Defaults to <code>msg.payload</code>.</dd>
+        <dt>Selection <span class="property-type">string</span></dt>
+        <dd>Specify which array elements to select using various formats: single indices, comma-separated lists, ranges, or step patterns.</dd>
+        <dt>Force Array <span class="property-type">boolean</span></dt>
+        <dd>When checked, always outputs an array even for single elements. Default: false (single elements output directly).</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">array</span></dt>
+        <dd>Input array from which to select elements. <strong>Must be an array</strong> - the node will warn and skip processing if input is not an array.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>configured output <span class="property-type">any | array</span></dt>
+        <dd>Selected element(s) written to the configured output path. Single elements output directly unless "Force Array" is enabled. Multiple elements always output as array.</dd>
+    </dl>
+
+    <h3>Selection Syntax</h3>
+    <ul>
+        <li><strong>Single Index:</strong> <code>0</code>, <code>2</code>, <code>-1</code> (negative indices count from end)</li>
+        <li><strong>Multiple Indices:</strong> <code>0,2,4</code>, <code>1,3,5</code> (comma-separated)</li>
+        <li><strong>Range:</strong> <code>1:4</code> (indices 1 to 3), <code>0:5</code> (indices 0 to 4)</li>
+        <li><strong>Step Range:</strong> <code>0::2</code> (every 2nd element), <code>1:7:2</code> (indices 1,3,5)</li>
+        <li><strong>Negative Ranges:</strong> <code>-2:</code> (last two elements), <code>:-2</code> (all but last two)</li>
+    </ul>
+
+    <h3>Examples</h3>
+    <p><strong>Input Array:</strong> <code>["A", "B", "C", "D", "E"]</code></p>
+    <ul>
+        <li><strong>Single:</strong> <code>0</code> → <code>"A"</code> (first element)</li>
+        <li><strong>Multiple:</strong> <code>1,3</code> → <code>["B", "D"]</code> (specific indices)</li>
+        <li><strong>Range:</strong> <code>1:4</code> → <code>["B", "C", "D"]</code> (slice range)</li>
+        <li><strong>Step:</strong> <code>0::2</code> → <code>["A", "C", "E"]</code> (every 2nd element)</li>
+        <li><strong>Negative:</strong> <code>-1</code> → <code>"E"</code> (last element)</li>
+        <li><strong>Last Two:</strong> <code>-2:</code> → <code>["D", "E"]</code> (from 2nd last to end)</li>
+    </ul>
+
+    <h3>Node Interactions</h3>
+    <p><strong>Works with:</strong> rp-array-out (to extract from assembled arrays), Transform nodes (to select processed results), any node that produces arrays</p>
+    <p><strong>Common Patterns:</strong> rp-array-out → rp-array-select (extract specific results), Transform → rp-array-select (pick best results), Image processing → rp-array-select (choose specific images)</p>
+
+    <h3>Output Behavior</h3>
+    <ul>
+        <li><strong>Single Element:</strong> Outputs the element directly (unless "Force Array" is checked)</li>
+        <li><strong>Multiple Elements:</strong> Always outputs as an array</li>
+        <li><strong>Empty Selection:</strong> Outputs empty array <code>[]</code></li>
+        <li><strong>Invalid Selection:</strong> No message sent, warning logged</li>
+        <li><strong>Out of Bounds:</strong> Invalid indices are ignored, warning logged</li>
+    </ul>
+
+    <h3>Error Handling</h3>
+    <p>Comprehensive validation and error reporting:</p>
+    <ul>
+        <li><strong>Non-array input:</strong> Warning logged, message not propagated</li>
+        <li><strong>Empty array:</strong> Warning logged, selection processed normally</li>
+        <li><strong>Invalid syntax:</strong> Warning logged, message not propagated</li>
+        <li><strong>Out-of-bounds indices:</strong> Invalid indices skipped, warning logged</li>
+        <li><strong>Status display:</strong> Shows current selection and processing state</li>
+    </ul>
+
+    <h3>Performance</h3>
+    <p>Selection operations are performed efficiently with minimal memory copying. Node status displays selection information and processing state.</p>
+</script>