node-red-contrib-join-wait 0.6.1 → 0.6.3

package/CHANGELOG.md

@@ -4,178 +4,202 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.6.3] - 2026-05-09
+
+### Fixed
+
+- **Open example flows button** is finally working. The 0.6.2 fix
+  invoked the import action via `RED.tray.close(cb)`'s callback, but
+  that callback fires before the `editor:close` event — so
+  clipboard.js's `disabled` guard was still set when the action ran,
+  and the dialog never appeared. Now listens for `editor:close`
+  explicitly and defers the action one tick past the synchronous
+  listener chain that clears the flag. Adds a guard against fast
+  double-clicks and a feature-detect fallback to
+  `core:show-import-dialog` for Node-RED < 3.1.
+
+### Changed
+
+- **`engines.node` lowered to `>=18.5`** to match the Node-RED 4.x
+  minimum (per the contrib-node packaging spec). CI matrix gains
+  Node 18 so the claim is verified, not asserted.
+- **Editor template updated to `const`/`let` and arrow functions**.
+  Pure stylistic refactor of `join-wait.html`'s IIFE; no behaviour
+  change. `function` is preserved where Node-RED binds `this`
+  (validators, `oneditprepare`/`save`/`resize`, jQuery `.each`/`.map`
+  callbacks).
+- Dropped the `node-red.examples` field from `package.json` — not
+  part of the packaging spec; examples auto-discover from
+  `examples/`.
+
+## [0.6.2] - 2026-05-09
+
+### Fixed
+
+- **Open example flows button** was a no-op. Now invokes
+  `core:show-examples-import-dialog` directly, opening the dialog as a
+  modal above the edit tray.
+- **Wait paths editableList overlapped the form rows below it** for
+  long lists. Resized via the canonical Node-RED pattern (numeric
+  height + `oneditresize` filling the tray, no upper clamp); re-flows
+  on the Advanced `<details>` toggle.
+- **Persist store admin call** now prefixes `RED.settings.apiRootUrl`,
+  so it works under a custom `httpAdminRoot` or behind a reverse
+  proxy.
+- **Help text** no longer references the file-based persistence path
+  removed in 0.6.0; corrected to describe the context-store backend.
+
+### Added
+
+- **Bulk paste in path lists** — paste newline-separated text into any
+  Wait paths or Reset paths row to fill the row + append one row per
+  remaining line.
+- **Richer inline validation** — output preview reflects
+  `pathTopicType` and shows repeat counts as `path_1 (×2): …`;
+  duplicate Reset paths and overlap between Wait/Reset paths are
+  flagged inline; Timeout accepts fractional values.
+- Tests for the `/join-wait/stores` admin endpoint and drift fences
+  in `editor_spec.js` so the help text never re-acquires legacy keys.
+
+### Changed
+
+- Persist store row hides when Preserve queue is off; output-preview
+  and Advanced summary use Node-RED CSS variables (theme-aware);
+  Timeout field widths cleaned up.
+
+## [0.6.1] - 2026-05-08
+
+### Fixed
+
+- Shipped example flows wouldn't import — inject nodes were missing
+  the standard top-level `topic`, `payload`, `repeat`, `crontab`,
+  `once`, and `onceDelay` fields. All five examples regenerated in
+  the canonical inject format.
+- First attempt at fixing the **Open example flows** button (closed
+  the edit tray before invoking the import dialog) — didn't reliably
+  surface; see 0.6.2 for the working fix.
+
 ## [0.6.0] - 2026-05-08
 
 ### Added
 
-- **Modern Node-RED `(msg, send, done)` input handler signature.** The
-  runtime now gets a proper `done()` / `done(err)` signal for every
-  message — meaningful for async-message tracking and graceful
-  shutdown. The async input handler previously relied on auto-completion,
-  which fired before any awaited work resolved.
-- **Smarter status indicator.** A single-group node shows progress toward
-  completion (e.g. `2/3 received`) rather than the raw queue depth.
-  Multi-group nodes still show aggregate counts.
-- Two more shipped example flows: `04-regex.json` (regex path matching)
-  and `05-exact-order.json` (exact-order with a repeated step).
-- **Editor UX overhaul.** Wait paths and reset paths now use Node-RED's
-  `editableList` widget — add/remove/reorder rows instead of typing JSON
-  arrays into a text box. Each row now validates inline (empty / invalid
-  regex are flagged red with a tooltip). Pressing <kbd>Enter</kbd> in a
-  row adds the next one.
-- **Persist store as a dropdown.** A new `/join-wait/stores` admin route
-  exposes the configured context stores; the editor populates the
-  Persist store field as a `<select>` showing each store's resolved
-  module (e.g. `file (localfilesystem)`). Eliminates typos and surfaces
-  available stores.
-- **Tooltips on every field label.** Hover-discoverable explanations
-  (`title` attributes) for every form row.
-- **Inline output-shape preview.** Under Wait paths, a small monospace
-  line shows what the merged success message looks like
-  (`→ msg.topic = { path_1: …, path_2: … }`), updating as the list
-  changes.
-- **Smart timeout warning.** When the resolved timeout is under 50 ms,
-  a yellow tip surfaces the README guidance about padding evaluation
-  overhead.
-- **Inline jsonata validation on Group by.** When the field type is
-  `jsonata`, the expression is parsed at edit-time and the field marks
-  invalid before the first message even arrives.
-- **Quick "Open example flows" button** in the editor opens the import
-  dialog directly.
-- Path-row placeholders changed from generic `path name` to a worked
-  example (`e.g. sensor_1`, `e.g. abort`) so empty rows hint at intent.
-- **Status-indicator error states.** Validation, regex compile, and
-  correlator-evaluation failures now show a red ring on the node with a
-  short reason in addition to the usual `node.error` log entry.
-- **Unhandled-rejection guard** around the async input handler so a future
-  bug or upstream throw can't escape without being logged.
-- End-to-end smoke test for **all five** shipped example flows, plus a
-  static config-shape sanity test on `join-wait.html` to catch drift
-  between the editor defaults and the runtime fields.
-- **Advanced settings** are collapsed under a single `<details>` group so
-  the editor presents the common options first.
-- **`msg.reset`** — sending `msg.reset = true` silently drains the queue
-  for the current correlation group with no output.
-- **`node.status()`** indicator showing the number of queued messages.
-- **Examples** — the package now ships three ready-made flows
-  (`Quickstart`, `Correlation`, `Reset paths`) discoverable via
-  **Menu → Import → Examples → join-wait**.
-- **Per-instance persistence store** — new `Persist store` field selects a
-  named context store from `settings.js` for restart-survival.
-- Unit-test specs for the `lib/config`, `lib/matcher`, and `lib/persist`
-  modules.
+- **Modern `(msg, send, done)` input handler** — proper async-message
+  tracking and graceful shutdown (the old auto-completion fired
+  before awaited work resolved).
+- **Editor UX overhaul** — Wait paths and Reset paths now use
+  `editableList` (add/remove/reorder rows; inline validation for
+  empty rows + invalid regex; Enter adds the next). Inline output
+  preview, smart short-timeout warning, jsonata-validity check on
+  Group by, tooltips on every label, an **Open example flows**
+  shortcut, and an **Advanced** collapsible. Field labels renamed
+  for clarity.
+- **Persist store dropdown** — new `/join-wait/stores` admin route
+  exposes the configured context stores; the editor renders a typo-proof
+  `<select>`.
+- **Smarter `node.status()`** — single-group nodes show progress
+  (`2/3 received`); validation / regex-compile / correlator-evaluation
+  failures show a red ring with a short reason.
+- **Five shipped example flows** — Quickstart, Correlation, Reset,
+  Regex, Exact order — discoverable via **Menu → Import → Examples
+  → join-wait**.
+- **`msg.reset`** silently drains the queue for the current
+  correlation group.
 
 ### Changed
 
-- **Renames for clarity.** Internal-only — config keys and runtime
-  behavior are unchanged for existing flows. `node.paths` → `node.queues`;
-  `node.topic` / `node.topicType` → `node.correlator` /
-  `node.correlatorType`; `node.pathTopic` / `node.pathTopicType` →
-  `node.pathField` / `node.pathFieldType`; `node.disableComplete` →
-  `node.ignoreMsgComplete`; `node.persistOnRestart` → `node.persistQueue`;
-  `node.firstMsg` → `node.useFirstAsBase`. The `clearQueue*` family →
-  `dropQueue` / `flushQueueAsExpired` / `flushOnMsgComplete` /
-  `flushTimedOutEntries` / `flushTrailingEntries`. Magic
-  `'_join-wait-node'` → `DEFAULT_GROUP` constant. `pickArrayOverride` →
-  `arrayOrFallback`.
-- **`drainQueue` now takes an options object** (`{ sendExpired,
-expireByTime, keep }`) instead of three positional booleans + a count.
-- **`findAllPaths{AnyOrder,ExactOrder}` return shape** changed from
-  `null | number` to `{ matched: true } | { matched: false, keep: number }`
-  for self-documenting call sites. Lib functions are not part of the
-  public API.
-- **`asBool()` helper** accepts both `'true'`/`'false'` strings (from the
-  HTML `<select>`) and real booleans (programmatic flow construction).
-  Removes a class of subtle defaults-bug for non-editor-built flows.
-- **`countPathsAnyOrder`** now uses a `Set` to track used indices
-  (O(1) check vs the previous O(n) `Array.indexOf`).
-- **Comment around `flushOnMsgComplete`** documents the deliberately
-  partial behavior: `msg.complete` short-circuits a partial queue but
-  never overrides a successful match.
-- **`node:` prefix on core imports** in test files (`node:fs`,
-  `node:os`, `node:path`).
-- **Expired output now uses the configured `Path field`** for the merged
-  data (matching the success output). Previously hardcoded to `msg.paths`
-  even when a different `pathTopic` was configured. Existing flows that
-  use the default `paths` setting see no change.
-- **Persistence rewritten on top of Node-RED's context store** (replacing
-  the `node-persist` singleton, which raced when multiple `join-wait` nodes
-  were deployed in the same flow). Default in-memory store keeps queues
-  across deploys; a configured persistent store keeps them across full
-  restarts.
-- **`Preserve queue` defaults to on** for new nodes. Partial joins now
-  survive a redeploy out of the box. Existing 0.5.x flows keep their
-  original `persistOnRestart: false` until re-saved.
-- **`Persist store` is no longer required** for restart persistence.
-  If `localfilesystem` (or similar) is set as the **default** context
-  store in `settings.js`, every join-wait node uses it automatically.
-- **Auto-pick of a persistent named store.** When `Preserve queue` is
-  on, `Persist store` is empty, and the configured default store is
-  memory, the node auto-selects the first non-memory named store from
-  `settings.js` (with a `node.log` line so it's discoverable). If the
-  user has both `default: memory` and (say) `file: localfilesystem`
-  configured, they get restart persistence for free without setting
-  `Persist store` on every node. Setting `Persist store` explicitly
-  always wins.
-- **British → American spellings.** `normalisePaths` → `normalizePaths`,
-  `serialisable` → `serializable`, `behaviour` → `behavior` in code +
-  docs for consistency with the wider JS / npm ecosystem.
-- **`msg.pathsToWait`, `msg.pathsToExpire`, `msg.useRegex` are now one-shot
-  overrides** — they apply only to the current message instead of
-  permanently mutating the node's stored config.
-- **Code split** into `lib/config.js`, `lib/matcher.js`, and `lib/persist.js`
-  — `join-wait.js` is now a thin orchestrator. The input handler is broken
-  into discrete named phases for readability.
-- **`mapPayload` no longer mutates the caller's `pathTopic` object** —
-  incoming messages are left untouched.
-- **jsonata bumped to v2** (`evaluate()` is now properly awaited).
-- **Node-RED bumped to ≥ 3.0**, **Node.js ≥ 18**.
-- **`engines.node`, `files`** added to `package.json`; deprecated
-  `licenses` array removed.
-- Source labels in the editor renamed for clarity:
-    - "Paths topic" → **Path field**
-    - "Paths (Wait)" / "Paths (Expire)" → **Wait paths** / **Reset paths**
-    - "Sequence order" → **Match order**
-    - "Base message" → **Output base**
-    - "Merged data" → **Merge values**
-- README rewritten — quickstart first, technical details after.
+- **Persistence rewritten on top of Node-RED's context store**,
+  replacing the `node-persist` singleton (which raced when multiple
+  `join-wait` nodes shared the flow). Default in-memory store keeps
+  queues across deploys; a configured persistent store keeps them
+  across full restarts. **Preserve queue** defaults to on; the node
+  auto-picks the first persistent named store when the default is
+  memory.
+- **`msg.pathsToWait`, `msg.pathsToExpire`, `msg.useRegex`** are now
+  one-shot overrides — they apply only to the current message
+  instead of permanently mutating the node's stored config.
+- **Expired output uses the configured Path field** for the merged
+  data (matched the success output). Previously hardcoded to
+  `msg.paths`.
+- **Code split** into `lib/config.js`, `lib/matcher.js`,
+  `lib/persist.js`; `findAllPaths{AnyOrder,ExactOrder}` return a
+  `{matched, keep}` shape; `drainQueue` takes options; internal
+  renames for clarity (config keys unchanged for back-compat).
+- jsonata bumped to v2 (proper async `evaluate()`); Node-RED ≥ 3.0,
+  Node.js ≥ 20.
 
 ### Fixed
 
-- **`node.error` / `node.warn` second argument now correctly passes the
-  originating `msg`** (was wrongly passed as `[msg, null]`, a 2-output
-  send array, since 0.5.x). Catch nodes downstream now receive the real
-  message instead of an array.
-- **Close handler always calls `done`**, even when the context-store
-  write rejects, so a transient persistence failure can't hold up
-  Node-RED shutdown.
-- Empty `<b></b>` tag in the help text.
-- Stale `ignoreUnmatched` references in older example flows.
+- `node.error` / `node.warn` correctly pass the originating `msg`
+  (previously passed as `[msg, null]` since 0.5.x — Catch nodes
+  downstream now receive the real message).
+- Close handler always calls `done` even when the context-store
+  write rejects, so persistence failures don't hold up shutdown.
+- `mapPayload` no longer mutates the caller's `pathTopic` object.
 - Possible race when multiple `join-wait` nodes shared the global
-  `node-persist` singleton (now uses an isolated context-store entry per
+  `node-persist` singleton (now an isolated context-store entry per
   node).
 
 ### Tooling
 
-- GitHub Actions CI replaces Travis (matrix on Node 20/22/24, publishing
-  on Node 24). CI + release now live in a single workflow; the publish
-  job is gated by `needs: [quality, test]` so a tag push only ships once
-  lint, format, spellcheck, and the full test matrix have all passed.
-- Workflow steps pinned to current `actions/checkout@v6`,
-  `actions/setup-node@v6`, `actions/upload-artifact@v6`.
-- `prettier --check` enforced in CI to catch unformatted files.
-- `engines.node` bumped to `>=20` (Node 18 EOL'd 2025-04-30).
-- Automated npm publish workflow with provenance on tag push.
-- Dependabot configured for monthly npm + GitHub Actions updates.
-- ESLint upgraded to v9 with flat config (`eslint.config.js`).
-- Prettier upgraded to v3.
-- Coverage moved from `nyc` to `c8` (native V8 coverage).
-- Spellcheck moved from the unmaintained `markdown-spellcheck` to `cspell`.
-- `node-red-node-test-helper` bumped from 0.2.x to 0.3.6.
-- Test suite expanded from 32 to 97 cases — including dedicated specs
-  for each `lib/` module, the editor HTML, and end-to-end runs of every
-  shipped example flow.
-
-## [0.5.3] and earlier
-
-See the [git log](https://github.com/dxdc/node-red-contrib-join-wait/commits/master).
+- GitHub Actions CI replaces Travis (matrix on Node 20/22/24);
+  publish job gated on lint + format + spellcheck + test matrix.
+  ESLint v9 (flat config), Prettier v3, c8 (replaces nyc), cspell
+  (replaces `markdown-spellcheck`); Dependabot for monthly npm + GHA
+  updates. Test suite expanded from 32 to 102 cases.
+
+## [0.5.3] - 2021-10-31
+
+- Update dependencies.
+
+## [0.5.2] - 2021-02-02
+
+- Retain state across restart
+  ([#7](https://github.com/dxdc/node-red-contrib-join-wait/issues/7)).
+
+## [0.5.1] - 2021-01-05
+
+- More automated testing and code coverage.
+
+## [0.5.0] - 2020-12-17
+
+- Expire earlier for "any order" mode
+  ([#4](https://github.com/dxdc/node-red-contrib-join-wait/issues/4)).
+
+## [0.4.5] - 2020-12-15
+
+- Add automated tests; address several minor issues uncovered by
+  testing; refactoring and readability changes.
+
+## [0.4.0] - 2020-12-14
+
+- Reworked logic for exact-order mode
+  ([#1](https://github.com/dxdc/node-red-contrib-join-wait/issues/1)).
+- Support for duplicate path names
+  ([#2](https://github.com/dxdc/node-red-contrib-join-wait/issues/2)).
+- Show all unmatched paths with individual warnings.
+- Minor changes to config UI and defaults.
+
+## [0.3.5] - 2020-05-26
+
+- Enforce unique path names.
+- Regex-based path matching.
+
+## [0.3.4] - 2020-01-17
+
+- Don't reuse the `msg` variable.
+
+## [0.3.3] - 2020-01-17
+
+- Fix bug with paths / `clearTimeout`.
+- Minor code optimizations; add Example 3 to documentation.
+
+## [0.3.2] - 2020-01-16
+
+- `msg.complete` handling.
+- `timeoutUnits` in settings.
+- `ignoreUnmatched` paths option in settings.
+- Updated documentation.
+
+## [0.3.0] - 2020-01-14
+
+- Initial release.

package/README.md

@@ -61,6 +61,11 @@ you want to wait for. That's it.
 > Looking for a working flow? After install, open
 > **Menu → Import → Examples → join-wait** for ready-made flows.
 
+> **Tip:** in the **Wait paths** / **Reset paths** lists you can press
+> <kbd>Enter</kbd> in a row to add the next one, and paste newline-separated
+> text into any row to fill the current row and append the rest as new
+> rows — handy for seeding a list from a spreadsheet column or a debug log.
+
 ## How it works
 
 ```

package/join-wait.html

@@ -15,8 +15,10 @@
         or an object with multiple keys.
     </div>
 
-    <div class="form-row">
+    <div class="form-row" style="margin-bottom:4px">
         <label title="Path names to wait for; repeat an entry to require it n times."><i class="fa fa-code-fork"></i> Wait paths</label>
+    </div>
+    <div class="form-row node-input-paths-container-row">
         <ol id="node-input-paths-container"></ol>
     </div>
     <div class="form-tips" style="margin-bottom:6px">
@@ -24,12 +26,12 @@
         merged success output. Press <kbd>Enter</kbd> in a row to add the
         next one. Repeat an entry to require n-of-the-same.
     </div>
-    <div class="form-tips" id="join-wait-output-preview" style="margin-bottom:12px; font-family:monospace; color:#888"></div>
+    <div class="form-tips" id="join-wait-output-preview" style="margin-bottom:12px; font-family:var(--red-ui-monospace-font, monospace)"></div>
 
     <div class="form-row">
         <label for="node-input-timeout" title="How long all wait paths have to arrive before the queue is expired."><i class="fa fa-clock-o"></i> Timeout</label>
-        <input type="text" id="node-input-timeout" style="text-align:end; width:100px !important" placeholder="15">
-        <select id="node-input-timeoutUnits" style="width:200px !important">
+        <input type="text" id="node-input-timeout" style="text-align:end; width:90px" placeholder="15">
+        <select id="node-input-timeoutUnits" style="width:160px; margin-left:5px">
             <option value="1">Milliseconds</option>
             <option value="1000">Seconds</option>
             <option value="60000">Minutes</option>
@@ -37,11 +39,13 @@
             <option value="86400000">Days</option>
         </select>
     </div>
-    <div class="form-tips" id="join-wait-timeout-hint" style="margin-bottom:12px; color:#b07b00; display:none"></div>
+    <div class="form-tips" id="join-wait-timeout-hint" style="margin-bottom:12px; color:#b07b00; display:none">
+        <i class="fa fa-exclamation-triangle"></i> <span></span>
+    </div>
 
     <div class="form-row">
         <label for="node-input-exactOrder" title="Any order (default) or strict sequence."><i class="fa fa-sort"></i> Match order</label>
-        <select id="node-input-exactOrder" style="width:70%; margin-right:5px;">
+        <select id="node-input-exactOrder" style="width:70%">
             <option value="false">Any order</option>
             <option value="true">Exact order</option>
         </select>
@@ -64,11 +68,13 @@
         </button>
     </div>
 
-    <details style="margin-top:14px">
-    <summary style="cursor:pointer; font-weight:bold; padding:6px 0">Advanced</summary>
+    <details class="join-wait-advanced" style="margin-top:14px">
+    <summary style="cursor:pointer; font-weight:bold; padding:6px 0; color:var(--red-ui-header-text-color, inherit)">Advanced</summary>
 
-    <div class="form-row" style="margin-top:10px">
+    <div class="form-row" style="margin-top:10px; margin-bottom:4px">
         <label title="Paths that immediately drain the queue to the expired output."><i class="fa fa-times-circle-o"></i> Reset paths</label>
+    </div>
+    <div class="form-row node-input-pathsToExpire-container-row">
         <ol id="node-input-pathsToExpire-container"></ol>
     </div>
     <div class="form-tips" style="margin-bottom:12px">
@@ -78,7 +84,7 @@
 
     <div class="form-row">
         <label for="node-input-firstMsg" title="Use the first or last message in the matched window as the base of the merged output."><i class="fa fa-comments-o"></i> Output base</label>
-        <select id="node-input-firstMsg" style="width:70%; margin-right:5px;">
+        <select id="node-input-firstMsg" style="width:70%">
             <option value="true">First received message</option>
             <option value="false">Last received message</option>
         </select>
@@ -86,7 +92,7 @@
 
     <div class="form-row">
         <label for="node-input-mapPayload" title="Keep the original Path-field values, or overwrite each with that message's payload."><i class="fa fa-arrow-right"></i> Merge values</label>
-        <select id="node-input-mapPayload" style="width:70%; margin-right:5px;">
+        <select id="node-input-mapPayload" style="width:70%">
             <option value="false">Original Path field values</option>
             <option value="true">Each msg.payload</option>
         </select>
@@ -116,13 +122,13 @@
         <label for="node-input-persistOnRestart" style="width:auto">Preserve queue across deploys / restarts</label>
     </div>
 
-    <div class="form-row">
+    <div class="form-row" id="join-wait-persist-store-row">
         <label for="node-input-persistStore" title="Override the context store used to persist the queue."><i class="fa fa-database"></i> Persist store</label>
-        <select id="node-input-persistStore" style="width:70%; margin-right:5px;">
+        <select id="node-input-persistStore" style="width:70%">
             <option value="">(default context store)</option>
         </select>
     </div>
-    <div class="form-tips" style="margin-bottom:12px">
+    <div class="form-tips" id="join-wait-persist-store-tip" style="margin-bottom:12px">
         Override the context store this node uses. Leave on default — set
         the default to a persistent store (e.g. <code>localfilesystem</code>)
         in <code>settings.js</code> and every join-wait node automatically
@@ -133,37 +139,65 @@
 
 <script type="text/javascript">
     (function () {
-        function arrayValidator(allowEmpty, requireUnique) {
-            return function (v) {
-                // Accept legacy JSON-string format too, for back-compat with old flows.
-                var arr = v;
-                if (typeof v === 'string') {
-                    if (v === '') return allowEmpty;
-                    try {
-                        arr = JSON.parse(v);
-                    } catch (err) {
-                        return false;
-                    }
-                }
-                if (!Array.isArray(arr)) return false;
-                if (arr.length === 0) return allowEmpty;
-                if (
-                    !arr.every(function (s) {
-                        return typeof s === 'string' && s.length > 0;
-                    })
-                )
+        // Every DOM hook the editor uses, in one place.
+        const SEL = {
+            pathField: '#node-input-pathTopic',
+            pathFieldType: '#node-input-pathTopicType',
+            correlator: '#node-input-correlationTopic',
+            correlatorType: '#node-input-correlationTopicType',
+            timeout: '#node-input-timeout',
+            timeoutUnits: '#node-input-timeoutUnits',
+            useRegex: '#node-input-useRegex',
+            persistOnRestart: '#node-input-persistOnRestart',
+            persistStore: '#node-input-persistStore',
+            outputPreview: '#join-wait-output-preview',
+            timeoutHint: '#join-wait-timeout-hint',
+            examplesButton: '#join-wait-open-examples',
+            persistStoreRow: '#join-wait-persist-store-row',
+            persistStoreTip: '#join-wait-persist-store-tip',
+            dialogForm: '#dialog-form',
+            advancedDetails: '#dialog-form details',
+        };
+        // editableList wrapper IDs (no leading '#'); consumers either
+        // pass them to readEditableList or interpolate `#` themselves.
+        const LIST_ID = {
+            paths: 'node-input-paths-container',
+            expire: 'node-input-pathsToExpire-container',
+        };
+        const listInputs = (id) => $('#' + id + ' input[type=text]');
+        // Path-field name + typedInput type, read together to avoid drift.
+        const readPathField = () => ({
+            name: $(SEL.pathField).val() || 'topic',
+            type: $(SEL.pathFieldType).val() || 'msg',
+        });
+
+        const arrayValidator = (allowEmpty, requireUnique) => (v) => {
+            // Accept legacy JSON-string format too, for back-compat with old flows.
+            let arr = v;
+            if (typeof v === 'string') {
+                if (v === '') return allowEmpty;
+                try {
+                    arr = JSON.parse(v);
+                } catch (err) {
                     return false;
-                if (requireUnique) {
-                    var seen = Object.create(null);
-                    for (var i = 0; i < arr.length; i++) {
-                        if (seen[arr[i]]) return false;
-                        seen[arr[i]] = true;
-                    }
                 }
-                return true;
-            };
-        }
+            }
+            if (!Array.isArray(arr)) return false;
+            if (arr.length === 0) return allowEmpty;
+            if (!arr.every((s) => typeof s === 'string' && s.length > 0)) return false;
+            if (requireUnique) {
+                const seen = Object.create(null);
+                for (let i = 0; i < arr.length; i++) {
+                    if (seen[arr[i]]) return false;
+                    seen[arr[i]] = true;
+                }
+            }
+            return true;
+        };
 
+        // Note: Node-RED calls validate functions with `this` bound to the
+        // node config, so this stays a function expression (arrow would
+        // not bind `this`).
         function correlationValidator(v) {
             // Empty / undefined / non-jsonata: nothing to validate here.
             if (this.correlationTopicType !== 'jsonata' || !v) return true;
@@ -177,162 +211,227 @@
             }
         }
 
-        function isValidRegex(s) {
+        const isValidRegex = (s) => {
             try {
                 new RegExp(s);
                 return true;
             } catch (err) {
                 return false;
             }
-        }
+        };
 
-        function setRowValid(input, ok, message) {
+        const setRowValid = (input, ok, message) => {
             input.css('border-color', ok ? '' : '#d9534f');
             input.attr('title', ok ? '' : message || '');
-        }
-
-        function validateRow(input) {
-            var $useRegex = $('#node-input-useRegex');
-            var v = String(input.val() || '');
-            if (v === '') {
+        };
+
+        // Single-row validation: empty / invalid regex. List-level
+        // checks (uniqueness, cross-list overlap) live in validateAllRows
+        // because they need both lists' current values in scope.
+        const validateRow = (input, ownValues, otherValues, opts) => {
+            const requireUnique = opts && opts.requireUnique;
+            const otherListLabel = (opts && opts.otherListLabel) || '';
+            const value = String(input.val() || '');
+            if (value === '') {
                 setRowValid(input, false, 'path name cannot be empty');
                 return false;
             }
-            if ($useRegex.is(':checked') && !isValidRegex(v)) {
+            if ($(SEL.useRegex).is(':checked') && !isValidRegex(value)) {
                 setRowValid(input, false, 'invalid regular expression');
                 return false;
             }
+            if (requireUnique && ownValues && ownValues.filter((x) => x === value).length > 1) {
+                setRowValid(input, false, 'duplicate entry — must be unique');
+                return false;
+            }
+            if (otherValues && otherValues.indexOf(value) !== -1) {
+                setRowValid(
+                    input,
+                    false,
+                    '"' + value + '" is also in ' + otherListLabel + " — paths shouldn't overlap",
+                );
+                return false;
+            }
             setRowValid(input, true);
             return true;
-        }
+        };
+
+        // Re-validate every row across both lists so duplicate and
+        // cross-list overlap warnings stay in sync.
+        const validateAllRows = () => {
+            const $paths = listInputs(LIST_ID.paths);
+            const $expire = listInputs(LIST_ID.expire);
+            // jQuery .map / .each callbacks rely on `this`, so they stay
+            // as function expressions.
+            const pathValues = $paths
+                .map(function () {
+                    return String($(this).val() || '');
+                })
+                .get();
+            const expireValues = $expire
+                .map(function () {
+                    return String($(this).val() || '');
+                })
+                .get();
+            $paths.each(function () {
+                validateRow($(this), pathValues, expireValues, {
+                    requireUnique: false,
+                    otherListLabel: 'Reset paths',
+                });
+            });
+            $expire.each(function () {
+                validateRow($(this), expireValues, pathValues, {
+                    requireUnique: true,
+                    otherListLabel: 'Wait paths',
+                });
+            });
+        };
 
-        function initEditableList(containerId, items, opts) {
-            var $container = $('#' + containerId);
-            $container.css({ 'min-height': '100px' });
-            var placeholder = (opts && opts.placeholder) || 'e.g. sensor_1';
+        const initEditableList = (containerId, items, opts) => {
+            const $container = $('#' + containerId);
+            const placeholder = (opts && opts.placeholder) || 'e.g. sensor_1';
+            // Numeric height → list scrolls internally past the limit.
+            // Recomputed in oneditresize to fill the tray.
             $container.editableList({
-                addItem: function (row, index, data) {
-                    var value = (data && data.value) || '';
+                addItem: (row, index, data) => {
+                    const value = (data && data.value) || '';
                     row.css({ overflow: 'hidden', whiteSpace: 'nowrap' });
-                    var input = $('<input/>', {
+                    const input = $('<input/>', {
                         type: 'text',
                         placeholder: placeholder,
                         style: 'width:100%',
                     }).val(value);
-                    input.on('input change blur', function () {
-                        validateRow(input);
+                    input.on('input change blur', () => {
+                        validateAllRows();
                         if (opts && opts.onChange) opts.onChange();
                     });
                     // Pressing Enter in a row adds the next one.
-                    input.on('keydown', function (e) {
+                    input.on('keydown', (e) => {
                         if (e.key === 'Enter' || e.keyCode === 13) {
                             e.preventDefault();
                             $container.editableList('addItem', { value: '' });
                             // Focus the newly-added row.
-                            setTimeout(function () {
+                            setTimeout(() => {
                                 $container.editableList('items').last().find('input').trigger('focus');
                             }, 0);
                         }
                     });
+                    // Bulk-paste newline-separated text into multiple
+                    // rows. Single-line pastes fall through to default.
+                    input.on('paste', (e) => {
+                        const clip = (e.originalEvent || e).clipboardData;
+                        if (!clip) return;
+                        const text = clip.getData('text');
+                        if (!text || !/[\r\n]/.test(text)) return;
+                        const lines = text
+                            .split(/\r?\n/)
+                            .map((s) => s.trim())
+                            .filter((s) => s.length > 0);
+                        if (lines.length === 0) return;
+                        e.preventDefault();
+                        input.val(lines[0]);
+                        for (let i = 1; i < lines.length; i++) {
+                            $container.editableList('addItem', { value: lines[i] });
+                        }
+                        validateAllRows();
+                        if (opts && opts.onChange) opts.onChange();
+                    });
                     row.append(input);
-                    validateRow(input);
+                    validateAllRows();
                     if (opts && opts.onChange) opts.onChange();
                 },
-                removeItem: function () {
+                removeItem: () => {
+                    validateAllRows();
                     if (opts && opts.onChange) opts.onChange();
                 },
                 removable: true,
                 sortable: true,
-                height: 'auto',
+                height: (opts && opts.height) || 200,
             });
-            (items || []).forEach(function (v) {
+            (items || []).forEach((v) => {
                 $container.editableList('addItem', { value: v });
             });
-        }
+        };
 
         // Re-validate every editableList row when the regex toggle flips.
-        function rebindRegexValidation() {
-            $('#node-input-useRegex').on('change', function () {
-                $(
-                    '#node-input-paths-container input[type=text], ' +
-                        '#node-input-pathsToExpire-container input[type=text]',
-                ).each(function () {
-                    validateRow($(this));
-                });
-            });
-        }
+        const rebindRegexValidation = () => {
+            $(SEL.useRegex).on('change', validateAllRows);
+        };
 
-        function readEditableList(containerId) {
-            var values = [];
+        const readEditableList = (containerId) => {
+            const values = [];
             $('#' + containerId)
                 .editableList('items')
                 .each(function () {
-                    var v = $(this).find('input').val();
+                    // jQuery `each` binds `this` to the row element, so
+                    // this callback stays a function expression.
+                    const v = $(this).find('input').val();
                     if (v != null && v !== '') values.push(v);
                 });
             return values;
-        }
+        };
 
         // Coerce legacy string-array values into a plain array for editing.
-        function toArray(v) {
+        const toArray = (v) => {
             if (Array.isArray(v)) return v;
             if (typeof v === 'string' && v !== '') {
                 try {
-                    var parsed = JSON.parse(v);
+                    const parsed = JSON.parse(v);
                     return Array.isArray(parsed) ? parsed : [];
                 } catch (err) {
                     return [];
                 }
             }
             return [];
-        }
-
-        // Render a tiny preview of what msg.<pathField> looks like on the
-        // success output, derived from the current Wait paths list.
-        function updateOutputPreview() {
-            var paths = readEditableList('node-input-paths-container');
-            var unique = [];
-            paths.forEach(function (p) {
-                if (unique.indexOf(p) === -1) unique.push(p);
+        };
+
+        // Preview of the merged success output. Repeated entries
+        // surface as `(×n)` so the n-of-the-same semantic is visible.
+        const updateOutputPreview = () => {
+            const paths = readEditableList(LIST_ID.paths);
+            const counts = Object.create(null);
+            const order = [];
+            paths.forEach((p) => {
+                if (counts[p] === undefined) order.push(p);
+                counts[p] = (counts[p] || 0) + 1;
             });
-            var pathField = $('#node-input-pathTopic').val() || 'topic';
-            var $tip = $('#join-wait-output-preview');
-            if (unique.length === 0) {
+            const field = readPathField();
+            const $tip = $(SEL.outputPreview);
+            if (order.length === 0) {
                 $tip.text('');
                 return;
             }
-            var entries = unique.slice(0, 4).map(function (p) {
-                return p + ': …';
-            });
-            if (unique.length > 4) entries.push('…');
-            $tip.text('→ msg.' + pathField + ' = { ' + entries.join(', ') + ' }');
-        }
+            const entries = order.slice(0, 4).map((p) => (counts[p] > 1 ? p + ' (×' + counts[p] + '): …' : p + ': …'));
+            if (order.length > 4) entries.push('…');
+            $tip.text('→ ' + field.type + '.' + field.name + ' = { ' + entries.join(', ') + ' }');
+        };
 
         // Warn when the resolved timeout is impractically short (the README
         // recommends padding ~5–10 ms for evaluation overhead).
-        function updateTimeoutHint() {
-            var t = Number($('#node-input-timeout').val()) || 0;
-            var u = Number($('#node-input-timeoutUnits').val()) || 1;
-            var ms = t * u;
-            var $hint = $('#join-wait-timeout-hint');
+        const updateTimeoutHint = () => {
+            const t = Number($(SEL.timeout).val()) || 0;
+            const u = Number($(SEL.timeoutUnits).val()) || 1;
+            const ms = t * u;
+            const $hint = $(SEL.timeoutHint);
             if (ms > 0 && ms < 50) {
-                $hint.text('Very short — pad ~10 ms to leave room for evaluation overhead.').show();
+                $hint.find('span').text('Very short — pad ~10 ms to leave room for evaluation overhead.');
+                $hint.show();
             } else {
                 $hint.hide();
             }
-        }
-
-        // Populate the Persist store <select> from the runtime via our
-        // /join-wait/stores admin route. Falls back gracefully if the route
-        // is unreachable or returns nothing useful.
-        function populatePersistStores(currentValue) {
-            var $sel = $('#node-input-persistStore');
-            $.getJSON('join-wait/stores')
-                .done(function (stores) {
-                    if (!Array.isArray(stores) || stores.length === 0) return;
-                    stores.forEach(function (s) {
+        };
+
+        // Populate the Persist store <select> from /join-wait/stores.
+        // apiRootUrl prefixes the call so it resolves under custom
+        // httpAdminRoot / reverse proxies.
+        const populatePersistStores = (currentValue) => {
+            const $sel = $(SEL.persistStore);
+            const base = (RED.settings && RED.settings.apiRootUrl) || '';
+            $.getJSON(base + 'join-wait/stores')
+                .done((stores) => {
+                    (Array.isArray(stores) ? stores : []).forEach((s) => {
                         if (s.name === 'default') return; // already represented as the blank option
-                        var label = s.module ? s.name + ' (' + s.module + ')' : s.name;
+                        const label = s.module ? s.name + ' (' + s.module + ')' : s.name;
                         $('<option/>').val(s.name).text(label).appendTo($sel);
                     });
                     // If the saved value isn't in the list, append it so we
@@ -345,28 +444,79 @@
                     }
                     $sel.val(currentValue || '');
                 })
-                .fail(function () {
-                    // Admin route not reachable — leave the select with just
-                    // its default option.
+                .fail(() => {
+                    // Admin route not reachable. Preserve the saved
+                    // value as an explicit option so the dropdown doesn't
+                    // silently overwrite persistStore with '' on save.
+                    if (currentValue) {
+                        $('<option/>')
+                            .val(currentValue)
+                            .text(currentValue + ' (stores list unavailable)')
+                            .appendTo($sel);
+                        $sel.val(currentValue);
+                    }
                 });
-        }
-
-        function openExamplesDialog() {
-            // The edit tray is on top of the editor, so the import tray
-            // can't surface beneath it. Close this tray first (which cancels
-            // the in-flight edit), then invoke the core import dialog so the
-            // user can pick Examples → join-wait.
-            var invoke = function () {
-                if (RED.actions && typeof RED.actions.invoke === 'function') {
-                    RED.actions.invoke('core:show-import-dialog');
-                }
+        };
+
+        // Last `size` handed to oneditresize. Cached so the <details>
+        // toggle handler can re-run the resize math without waiting for
+        // the next tray drag.
+        let lastTraySize = null;
+
+        // Stretch the Wait paths editableList to fill the tray —
+        // pattern from core switch/change/httprequest.
+        const resizePathsList = () => {
+            const $form = $(SEL.dialogForm);
+            if (!$form.length || !lastTraySize || !lastTraySize.height) return;
+            let height = lastTraySize.height;
+            // jQuery `.each` binds `this` to the row element, so this
+            // callback stays a function expression.
+            $form.children(':not(.node-input-paths-container-row)').each(function () {
+                const $r = $(this);
+                if ($r.is(':visible')) height -= $r.outerHeight(true) || 0;
+            });
+            height -= 12; // breathing room for margins/padding the loop misses
+            if (height < 140) height = 140;
+            $('#' + LIST_ID.paths).editableList('height', height);
+        };
+
+        // clipboard.js disables import actions while an edit tray is
+        // open, and RED.tray.close(cb) fires cb before the editor:close
+        // event — so we listen for editor:close ourselves and defer one
+        // tick past the synchronous listener chain that clears the flag.
+        // The pending guard suppresses a fast double-click registering
+        // two listeners.
+        let pendingExamplesOpen = false;
+        const openExamplesDialog = () => {
+            if (pendingExamplesOpen) return;
+            pendingExamplesOpen = true;
+            const invoke = () => {
+                setTimeout(() => {
+                    pendingExamplesOpen = false;
+                    if (!RED.actions || typeof RED.actions.invoke !== 'function') return;
+                    // core:show-examples-import-dialog was added in Node-RED 3.1.
+                    const actions = RED.actions.list && RED.actions.list();
+                    const hasExamples =
+                        Array.isArray(actions) &&
+                        actions.some((a) => (a && a.id) === 'core:show-examples-import-dialog');
+                    RED.actions.invoke(hasExamples ? 'core:show-examples-import-dialog' : 'core:show-import-dialog');
+                }, 0);
             };
+            if (RED.events && typeof RED.events.once === 'function') {
+                RED.events.once('editor:close', invoke);
+            } else if (RED.events && typeof RED.events.on === 'function') {
+                const handler = () => {
+                    if (RED.events.off) RED.events.off('editor:close', handler);
+                    invoke();
+                };
+                RED.events.on('editor:close', handler);
+            }
             if (RED.tray && typeof RED.tray.close === 'function') {
-                RED.tray.close(invoke);
+                RED.tray.close();
             } else {
                 invoke();
             }
-        }
+        };
 
         RED.nodes.registerType('join-wait', {
             category: 'function',
@@ -393,10 +543,9 @@
                 firstMsg: { value: 'true', required: true },
                 mapPayload: { value: 'false', required: true },
                 disableComplete: { value: false },
-                // Defaults to true so the queue survives a redeploy out of
-                // the box (uses the default in-memory context store).
-                // For full Node-RED restart persistence the user still needs
-                // to point Persist store at a configured persistent store.
+                // On by default → survives redeploys via the in-memory
+                // context store. Restart-persistence still needs Persist
+                // store pointing at a persistent context.
                 persistOnRestart: { value: true },
                 persistStore: { value: '' },
             },
@@ -411,14 +560,14 @@
                 return this.name ? 'node_label_italic' : '';
             },
             oneditprepare: function () {
-                $('#node-input-pathTopic').typedInput({
+                $(SEL.pathField).typedInput({
                     default: this.pathTopicType || 'msg',
-                    typeField: $('#node-input-pathTopicType'),
+                    typeField: $(SEL.pathFieldType),
                     types: ['msg', 'flow', 'global'],
                 });
-                $('#node-input-correlationTopic').typedInput({
+                $(SEL.correlator).typedInput({
                     default: this.correlationTopicType || 'undefined',
-                    typeField: $('#node-input-correlationTopicType'),
+                    typeField: $(SEL.correlatorType),
                     types: [
                         { value: 'undefined', label: RED._('common.type.undefined'), hasValue: false },
                         'msg',
@@ -427,34 +576,50 @@
                         'jsonata',
                     ],
                 });
-                $('#node-input-timeout').spinner({ min: 1 });
+                // Decimals OK (runtime multiplies by the unit factor).
+                $(SEL.timeout).spinner({ min: 0.001, step: 1, numberFormat: 'n' });
 
-                initEditableList('node-input-paths-container', toArray(this.paths), {
+                initEditableList(LIST_ID.paths, toArray(this.paths), {
                     placeholder: 'e.g. sensor_1',
                     onChange: updateOutputPreview,
+                    height: 200,
                 });
-                initEditableList('node-input-pathsToExpire-container', toArray(this.pathsToExpire), {
+                initEditableList(LIST_ID.expire, toArray(this.pathsToExpire), {
                     placeholder: 'e.g. abort',
+                    height: 140,
                 });
                 rebindRegexValidation();
 
-                $('#node-input-pathTopic').on('change input', updateOutputPreview);
+                $(SEL.pathField).on('change input', updateOutputPreview);
                 updateOutputPreview();
 
-                $('#node-input-timeout, #node-input-timeoutUnits').on('change input', updateTimeoutHint);
+                $(SEL.timeout + ', ' + SEL.timeoutUnits).on('change input', updateTimeoutHint);
                 updateTimeoutHint();
 
                 populatePersistStores(this.persistStore);
 
-                $('#join-wait-open-examples').on('click', openExamplesDialog);
+                // Persist store row is meaningless without Preserve queue.
+                const $persistRow = $(SEL.persistStoreRow + ', ' + SEL.persistStoreTip);
+                const syncPersistStoreVisibility = () => {
+                    $persistRow.toggle($(SEL.persistOnRestart).is(':checked'));
+                    resizePathsList();
+                };
+                $(SEL.persistOnRestart).on('change', syncPersistStoreVisibility);
+                syncPersistStoreVisibility();
+
+                $(SEL.examplesButton).on('click', openExamplesDialog);
+
+                // Reflow the list when Advanced toggles (oneditresize
+                // only fires on tray drag).
+                $(SEL.advancedDetails).on('toggle', resizePathsList);
             },
             oneditsave: function () {
-                this.paths = readEditableList('node-input-paths-container');
-                this.pathsToExpire = readEditableList('node-input-pathsToExpire-container');
+                this.paths = readEditableList(LIST_ID.paths);
+                this.pathsToExpire = readEditableList(LIST_ID.expire);
             },
-            oneditresize: function () {
-                $('#node-input-paths-container').css('min-height', '100px');
-                $('#node-input-pathsToExpire-container').css('min-height', '60px');
+            oneditresize: function (size) {
+                lastTraySize = size;
+                resizePathsList();
             },
         });
     })();
@@ -550,8 +715,12 @@
         is kept in the merged output.</li>
         <li>Pad <b>Timeout</b> with a small overhead (~5–10&nbsp;ms) for
         evaluation time when working with very short windows.</li>
-        <li>When <b>Preserve queue</b> is on, the queue is saved to a JSON
-        file under <code>{userDir}/join-wait/{nodeId}.json</code> on close
-        and reloaded on next start.</li>
+        <li>When <b>Preserve queue</b> is on, the queue is written to the
+        node's context on close (and reloaded on the next start). With
+        the default in-memory store this only survives a redeploy; for
+        full restart persistence, point <b>Persist store</b> at a
+        store backed by <code>localfilesystem</code> (or any persistent
+        module) configured under <code>contextStorage</code> in
+        <code>settings.js</code>.</li>
     </ul>
 </script>

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-join-wait",
-    "version": "0.6.1",
+    "version": "0.6.3",
     "description": "Node-RED node that joins related messages across multiple paths within a time window — with exact-order matching, regex paths, correlation grouping, reset paths, and queue persistence. Coordinate parallel flows, synchronize events, and debounce sensors.",
     "author": "Daniel Caspi <dan@element26.net>",
     "license": "MIT",
@@ -24,7 +24,7 @@
     ],
     "main": "join-wait.js",
     "engines": {
-        "node": ">=20"
+        "node": ">=18.5"
     },
     "files": [
         "join-wait.js",
@@ -63,8 +63,7 @@
         "version": ">=3.0.0",
         "nodes": {
             "join-wait": "join-wait.js"
-        },
-        "examples": "examples"
+        }
     },
     "dependencies": {
         "jsonata": "^2.0.5"