@nrutils/node-red-utils 0.0.0-stage → 0.1.0

package/node-red-pubsub-bus/NodeRedPubsubBusWorkerProxy.js

@@ -0,0 +1,239 @@
+/**
+ * Copyright 2024 Contributors
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+'use strict';
+
+//
+// Worker-side counterpart to NodeRedPubsubBus. Same surface as the main-thread
+// bus, but every call serializes over `parentPort`. Expects the host main-thread
+// to have called `pubsubBus.attachWorker(worker)`. If that didn't happen, calls
+// fall on the floor. The first call also sends a ping; attachWorker answers it.
+// If no answer comes within 5s, a one-time warning is logged.
+//
+
+const { parentPort } = require('worker_threads');
+
+// getMetadata fails after this time without a reply from the main thread
+const PULL_TIMEOUT_MS = 5000;
+
+/**
+ * Worker-side proxy for the main-thread NodeRedPubsubBus. Singleton per worker
+ * isolate; the worker only ever talks to one parentPort.
+ */
+class NodeRedPubsubBusWorkerProxy {
+
+    constructor() {
+        // subId -> handler
+        this._subscribers = new Map();
+        // producerId -> getMetadata
+        this._producerMetadataFns = new Map();
+        // producerId -> getEntries (so notifyChange can refresh main-side entry cache)
+        this._producerEntriesFns = new Map();
+        // reqId -> { resolve, reject } for pulls we issued to main
+        this._pendingPulls = new Map();
+
+        this._nextSubId = 1;
+        this._nextLocalId = 1;
+        this._nextPullId = 1;
+
+        this._anyMessageReceived = false;
+        this._firstSendAt = null;
+        this._warnedNoBridge = false;
+        this._warnTimer = null;
+
+        if (parentPort) {
+            parentPort.on('message', (message) => this._onMessage(message));
+        }
+    }
+
+    /**
+     * Publishes a message via the main-thread bus.
+     * @param {string} topic
+     * @param {object} msg
+     */
+    publish(topic, msg) {
+        this._send({ tag: 'pubsub:publish', topic, msg });
+    }
+
+    /**
+     * Subscribes to a topic via the main-thread bus.
+     * @param {string} topic
+     * @param {Function} handler
+     * @returns {Function} unsubscribe
+     */
+    subscribe(topic, handler) {
+        if (typeof handler !== 'function') {
+            throw new Error('NodeRedPubsubBusWorkerProxy: handler must be a function');
+        }
+        const subId = this._nextSubId++;
+        this._subscribers.set(subId, handler);
+        this._send({ tag: 'pubsub:subscribe', subId, topic });
+        return () => {
+            if (!this._subscribers.has(subId)) return;
+            this._subscribers.delete(subId);
+            this._send({ tag: 'pubsub:unsubscribe', subId });
+        };
+    }
+
+    /**
+     * Registers a producer with the main-thread bus. Local getMetadata is retained
+     * to satisfy main → worker `pubsub:get-metadata` requests.
+     * @param {string} producerId
+     * @param {{ getEntries: Function, getMetadata: Function }} opts
+     * @returns {Function} unregister
+     */
+    registerProducer(producerId, { getEntries, getMetadata }) {
+        if (typeof getEntries !== 'function' || typeof getMetadata !== 'function') {
+            throw new Error('NodeRedPubsubBusWorkerProxy: registerProducer requires getEntries and getMetadata fns');
+        }
+        if (this._producerMetadataFns.has(producerId)) {
+            throw new Error(`NodeRedPubsubBusWorkerProxy: producer '${producerId}' already registered`);
+        }
+        this._producerMetadataFns.set(producerId, getMetadata);
+        this._producerEntriesFns.set(producerId, getEntries);
+        this._send({ tag: 'pubsub:register', producerId, entries: getEntries() });
+
+        return () => {
+            if (!this._producerMetadataFns.has(producerId)) return;
+            this._producerMetadataFns.delete(producerId);
+            this._producerEntriesFns.delete(producerId);
+            // Note: spec defines no explicit `pubsub:unregister` tag. Producer
+            // teardown is normally driven by worker exit, which auto-detaches
+            // on the main side. If a host wants to revoke a producer without
+            // exiting, that's an out-of-band concern beyond this spec.
+        };
+    }
+
+    /**
+     * Asks the main-thread bus to fire a `change` event for a single entry of
+     * a worker-side producer. Use after mutating the cached metadata payload
+     * so subscribers re-pull via getMetadata.
+     * @param {string} producerId
+     * @param {string} name
+     */
+    notifyChange(producerId, name) {
+        // Re-send the current entries snapshot so the main-side cache stays in
+        // sync — entries can change dynamically as the worker discovers/loses
+        // upstream channels.
+        const getEntries = this._producerEntriesFns.get(producerId);
+        const entries = getEntries ? getEntries() : null;
+        this._send({ tag: 'pubsub:notify-change', producerId, name, entries });
+    }
+
+    /**
+     * Pulls metadata for any registered producer/entry through the main-thread bus.
+     * Returns a Promise that resolves to the payload (or null if unregistered).
+     * It rejects if no reply comes within PULL_TIMEOUT_MS, for example without attachWorker().
+     * @param {string} producerId
+     * @param {string} name
+     * @returns {Promise<*>}
+     */
+    getMetadata(producerId, name) {
+        return new Promise((resolve, reject) => {
+            const reqId = this._nextPullId++;
+            const timer = setTimeout(() => {
+                if (!this._pendingPulls.delete(reqId)) return;
+                reject(new Error(`NodeRedPubsubBusWorkerProxy: getMetadata('${producerId}', '${name}'): ` +
+                    `no reply from the main thread within ${PULL_TIMEOUT_MS} ms. Did the host call attachWorker(worker)?`));
+            }, PULL_TIMEOUT_MS);
+            if (typeof timer.unref === 'function') timer.unref();
+            this._pendingPulls.set(reqId, { resolve, reject, timer });
+            this._send({ tag: 'pubsub:pull-metadata', reqId, producerId, name });
+        });
+    }
+
+    /** @private */
+    _onMessage(message) {
+        if (!message || typeof message !== 'object') return;
+        this._anyMessageReceived = true;
+        if (this._warnTimer) {
+            clearTimeout(this._warnTimer);
+            this._warnTimer = null;
+        }
+        switch (message.tag) {
+            case 'pubsub:event':
+                this._handleEvent(message);
+                break;
+            case 'pubsub:get-metadata':
+                this._handleGetMetadata(message);
+                break;
+            case 'pubsub:pull-metadata-reply':
+                this._handlePullMetadataReply(message);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /** @private */
+    _handlePullMetadataReply(message) {
+        const { reqId, payload } = message;
+        const pending = this._pendingPulls.get(reqId);
+        if (!pending) return;
+        this._pendingPulls.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(payload);
+    }
+
+    /** @private */
+    _handleEvent(message) {
+        const { subId, msg } = message;
+        const handler = this._subscribers.get(subId);
+        if (!handler) return;
+        const report = (err) => console.error('NodeRedPubsubBusWorkerProxy: subscriber handler failed', err);
+        try {
+            const result = handler(msg);
+            if (result && typeof result.then === 'function') result.then(undefined, report);
+        } catch (err) { report(err); }
+    }
+
+    /** @private */
+    _handleGetMetadata(message) {
+        const { reqId, producerId, name } = message;
+        const getMetadata = this._producerMetadataFns.get(producerId);
+        if (!getMetadata) {
+            this._send({ tag: 'pubsub:get-metadata-reply', reqId, payload: null });
+            return;
+        }
+        Promise.resolve()
+            .then(() => getMetadata(name))
+            .then((payload) => {
+                this._send({ tag: 'pubsub:get-metadata-reply', reqId, payload: payload || null });
+            })
+            .catch((err) => {
+                console.error('NodeRedPubsubBusWorkerProxy: getMetadata threw', err);
+                this._send({ tag: 'pubsub:get-metadata-reply', reqId, payload: null });
+            });
+    }
+
+    /** @private */
+    _send(message) {
+        if (!parentPort) return;
+        if (this._firstSendAt === null) {
+            this._firstSendAt = Date.now();
+            this._warnTimer = setTimeout(() => {
+                if (!this._anyMessageReceived && !this._warnedNoBridge) {
+                    this._warnedNoBridge = true;
+                    console.warn('NodeRedPubsubBusWorkerProxy: no main-side bridge detected after 5s. Did the host call pubsubBus.attachWorker(worker)?');
+                }
+            }, 5000);
+            if (typeof this._warnTimer.unref === 'function') this._warnTimer.unref();
+            // attachWorker answers this, so a producer-only worker also gets a reply
+            parentPort.postMessage({ tag: 'pubsub:ping' });
+        }
+        try {
+            parentPort.postMessage(message);
+        } catch (err) {
+            console.error('NodeRedPubsubBusWorkerProxy: postMessage failed', err);
+        }
+    }
+}
+
+const pubsubWorkerProxy = new NodeRedPubsubBusWorkerProxy();
+
+module.exports = pubsubWorkerProxy;
+module.exports.NodeRedPubsubBusWorkerProxy = NodeRedPubsubBusWorkerProxy;
+module.exports.pubsubWorkerProxy = pubsubWorkerProxy;

package/node-red-pubsub-bus/README.md

@@ -0,0 +1,201 @@
+# node-red-pubsub-bus
+
+An in-process pub/sub bus for data that nodes share without a wire: readings, settings, calibration, schemas.
+
+A producer node offers named entries. A consumer subscribes to an entry and gets an event when the entry changes. The event does not carry the value; the consumer asks the producer for the current value with `getMetadata`. A consumer that subscribes after the producer has registered the entry gets one `connect` event, so it can ask for the value at once. If the producer has no such entry yet, the consumer gets nothing until the producer adds the entry and calls `notifyChange`.
+
+## Usage
+
+A producer node reads the CPU temperature every 2 seconds and offers it as the entry `latest`. It has no input and no wire:
+
+```js
+const fs = require('fs');
+const { NodeRedNodeBase, nodeRedPubsubBus } = require('@nrutils/node-red-utils');
+
+// Reads the CPU temperature every 2 s and offers it on the bus as the entry 'latest'
+module.exports = NodeRedNodeBase.createNode('cpu-temp', [nodeRedPubsubBus], (RED, thisNode, config) => {
+    const bus = thisNode.nodeRedPubsubBus;
+    let latest = null;
+
+    bus.registerProducer(thisNode.id, {
+        getEntries: () => (latest === null ? [] : [{ name: 'latest', type: 'acme/reading_v1' }]),
+        getMetadata: (name) => (name === 'latest' ? latest : null)
+    });
+
+    const timer = setInterval(() => {
+        fs.readFile('/sys/class/thermal/thermal_zone0/temp', 'utf8', (err, text) => {
+            if (err) return thisNode.status({ fill: 'red', shape: 'ring', text: err.code });
+            const celsius = Number(text) / 1000;
+            if (latest && latest.celsius === celsius) return;   // no change, no event
+            latest = { celsius, time: Date.now() };
+            bus.notifyChange(thisNode.id, 'latest');
+        });
+    }, 2000);
+    thisNode.on('close', () => clearInterval(timer));
+});
+```
+
+A consumer node subscribes to `<producerId>/<entry>` and pulls the value on each event:
+
+```js
+const { NodeRedNodeBase, nodeRedPubsubBus } = require('@nrutils/node-red-utils');
+
+module.exports = NodeRedNodeBase.createNode('bus-consumer', [nodeRedPubsubBus], (RED, thisNode, config) => {
+    const bus = thisNode.nodeRedPubsubBus;
+
+    if (!config.producer) {                 // no producer selected in the edit dialog
+        thisNode.status({ fill: 'grey', shape: 'ring', text: 'no producer selected' });
+        return;
+    }
+
+    bus.subscribe(`${config.producer}/latest`, async (event) => {
+        if (event.kind === 'disconnect') {  // the producer is gone
+            thisNode.status({ text: 'no producer' });
+            return;
+        }
+        try {
+            const value = await bus.getMetadata(event.producerId, event.desc);
+            if (value === null) return;     // no value yet, or the producer is gone
+            thisNode.send({ payload: value, kind: event.kind });
+        } catch (err) {
+            thisNode.error(err);            // for example a worker producer that did not reply
+        }
+    });
+});
+```
+
+Use as many consumer nodes as you need, on any flow tab. Each one reads the same producer. A consumer that is deployed later gets `connect` and pulls the current reading at once.
+
+`config.producer` is the producer's node id. In the editor, fill a dropdown from the [discovery endpoint](#discovery-endpoint); see [Producer dropdown in the edit dialog](#producer-dropdown-in-the-edit-dialog).
+
+## How it works
+
+- Events carry no payload. Every event is `{ producerId, desc, type, kind }`, where `desc` is the entry name. The consumer pulls the value with `getMetadata`, so it never acts on a stale copy.
+- `kind` is one of:
+  - `'change'`: goes to all subscribers of the entry when the producer registers or calls `notifyChange`.
+  - `'connect'`: goes to one new subscriber if the entry already exists.
+  - `'disconnect'`: goes to all subscribers of the entry when the producer unregisters: its node closes (redeploy, delete), its worker exits, or it calls `unregister()`. The subscription stays. If the producer comes back with the same id, the subscriber gets a `change`.
+
+  Handle `change` and `connect` the same way: pull now. On `disconnect`, show that the producer is gone.
+- `getEntries()` decides what exists. An entry that `getEntries()` does not return gets no events, does not show in `listProducers()`, and does not get a `disconnect`. Return `[]` to hide the entries until there is a value.
+- `type` is a free-form string that the producer picks, such as `acme/reading_v1`. The bus does not check it.
+- The method names call the value "metadata" (`getMetadata`). It can be any value.
+- When a node closes, the mixin removes its subscriptions, its producers, its `onProducerRegistered` handlers and its attached workers. When a worker exits, the bus removes everything that the worker registered. Subscribers of the removed producers get `disconnect`.
+- There is one bus per Node-RED process. Producer ids must be unique; `thisNode.id` is a good choice.
+
+## API
+
+All methods are on `thisNode.nodeRedPubsubBus`.
+
+- `registerProducer(producerId, { getEntries, getMetadata })` returns `unregister()`. `getEntries()` returns `[{ name, type }]`. `getMetadata(name)` returns the value or a Promise. Throws if `producerId` is already registered. `producerId` must not contain `/`, because the topic `<producerId>/<entry>` uses `/` to separate the two parts.
+- `notifyChange(producerId, name)`: send a `change` for one entry. Call it after the value changes. If `getEntries()` has no entry `name` (or the producer is not registered), nothing is sent; the node logs a line at `debug` level. Add the entry to `getEntries()` first.
+- `subscribe(topic, handler)` returns `unsubscribe()`. `topic` is `<producerId>/<entry>`. `handler(event)` can be `async`. If it throws or its Promise rejects, the node logs `pubsub subscriber of <topic> failed: <message>` with `node.error`, and the other subscribers and the producer are not affected.
+- `getMetadata(producerId, name)`: always a Promise for the value. It gives `null` if there is no such producer. A producer also returns `null` when it has no value yet, so treat `null` as "no value now". The Promise rejects if the producer's `getMetadata` throws, or if a worker producer does not reply within 5 seconds, so use `await` in a `try`/`catch`.
+- `publish(topic, event)`: emit your own event. It must have `producerId`, `desc`, `type` and `kind`.
+- `onProducerRegistered(handler)` returns `unsubscribe()`. Calls `handler(producerId)` for each new producer, for example one that starts after deploy.
+- `listProducers()`: `[{ producerId, entries: [{ name, type }] }]`. It holds only producers that are registered now, which means deployed and running nodes, from all node packages in this Node-RED. A node that is in the editor but not deployed is not in the list.
+- `listTopics()`, `listSubscribers(topic)`: topic names and the subscriber count, for debugging.
+- `attachWorker(worker)` returns `detach()`. Connects a worker thread to the bus; see below.
+
+## Discovery endpoint
+
+The mixin adds `GET /node-red-pubsub-bus/producers` to the admin API when Node-RED loads a node type that uses it, so the route exists before the first deploy. It returns `listProducers()` as JSON (`[]` if no producer runs) and needs the `flows.read` permission. In the editor, use a relative URL, so that the editor sends its login token:
+
+```js
+$.getJSON('node-red-pubsub-bus/producers', (producers) => { /* fill a <select> */ });
+```
+
+## Producer dropdown in the edit dialog
+
+A consumer node stores the producer's node id in a `producer` property. This edit dialog lists the running producers that have an entry `latest` of type `acme/reading_v1`. Each option shows the producer node's name from the editor (`RED.nodes.node(id)`), so the producer needs no label option. If the saved producer does not run now (not deployed, or its worker stopped), the dialog keeps it as a "not running" option, so opening and closing the dialog does not clear it.
+
+```html
+<script type="text/javascript">
+    RED.nodes.registerType('bus-consumer', {
+        category: 'function',
+        defaults: { name: { value: '' }, producer: { value: '' } },
+        inputs: 1,
+        outputs: 1,
+        label: function () { return this.name || 'bus-consumer'; },
+        oneditprepare: function () {
+            const node = this;
+            const select = $('#node-input-producer');
+            const label = (id) => { const n = RED.nodes.node(id); return (n && n.name) || id; };
+            $.getJSON('node-red-pubsub-bus/producers', function (producers) {
+                const running = producers.filter((p) =>
+                    p.entries.some((e) => e.name === 'latest' && e.type === 'acme/reading_v1'));
+                select.empty().append($('<option>').val('').text('- select a producer -'));
+                for (const p of running) {
+                    select.append($('<option>').val(p.producerId).text(label(p.producerId)));
+                }
+                if (node.producer && !running.some((p) => p.producerId === node.producer)) {
+                    select.append($('<option>').val(node.producer).text(label(node.producer) + ' (not running)'));
+                }
+                select.val(node.producer);
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="bus-consumer">
+    <div class="form-row">
+        <label for="node-input-name">Name</label>
+        <input type="text" id="node-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-producer">Producer</label>
+        <select id="node-input-producer"></select>
+    </div>
+</script>
+```
+
+Points to know:
+
+- Only deployed, running producers are in the list. Add a producer node, then deploy, then open the consumer's dialog.
+- A producer whose `getEntries()` returns `[]` (no value yet) does not pass the filter.
+- The list holds producers of all node packages. Filter by entry name and `type` to keep only the ones your node can read.
+
+## Producers in a worker thread
+
+If the data lives in a [worker](../node-red-worker/README.md), attach the worker on the main thread:
+
+```js
+const path = require('path');
+const { NodeRedNodeBase, nodeRedWorker, nodeRedPubsubBus } = require('@nrutils/node-red-utils');
+
+module.exports = NodeRedNodeBase.createNode('bus-worker-producer', [nodeRedWorker, nodeRedPubsubBus], (RED, thisNode, config) => {
+    const worker = thisNode.nodeRedWorker.init(path.join(__dirname, 'worker.js'), { id: thisNode.id });
+    thisNode.nodeRedPubsubBus.attachWorker(worker);
+});
+```
+
+Then use the worker proxy in the worker file:
+
+```js
+const pubsub = require('@nrutils/node-red-utils/node-red-pubsub-bus-workerproxy');
+
+module.exports = function (worker, data) {
+    let latest = null;
+    pubsub.registerProducer(data.id, {
+        getEntries: () => (latest === null ? [] : [{ name: 'latest', type: 'acme/reading_v1' }]),
+        getMetadata: (name) => (name === 'latest' ? latest : null)
+    });
+    worker.parentPorts.subscribe('reading', (value) => {
+        latest = value;
+        pubsub.notifyChange(data.id, 'latest');
+    });
+};
+```
+
+Life of a worker producer:
+
+- Use the node id as the producer id: pass `thisNode.id` to the worker and register with it. Producer ids are unique in the process, and consumers store this id.
+- On a redeploy the old node closes first. The mixin detaches its worker, the bus removes the producer, and subscribers get `disconnect`. Then the new node starts a new worker, which registers the same id again, and subscribers get `change`.
+- If a worker registers an id that is already registered, the bus does not register it. The node logs the error and shows a red status. Node-RED keeps running.
+- With `nodeRedWorker`, the close handler needs no pubsub code: the mixin detaches the worker and `nodeRedWorker` stops it.
+- With a raw `new Worker(...)`, the mixin also detaches it on close, but the thread keeps running. Call `worker.terminate()` in your close handler.
+- `unregister()` from the proxy only stops the worker's own answers. The main thread removes a worker producer when the node closes or the worker exits.
+
+The proxy has `publish`, `subscribe`, `registerProducer`, `notifyChange` and `getMetadata`. Each call goes to the main-thread bus over `parentPort`; `getMetadata` always returns a Promise. That Promise rejects after 5 seconds without a reply, for example when the host did not call `attachWorker`. On its first call the proxy sends a ping that `attachWorker` answers. If no answer comes within 5 seconds, the proxy logs one warning. The usual cause is a missing `attachWorker`.
+
+[Back to node-red-utils](../README.md)

package/node-red-resourceendpoint/NodeRedResourceEndpoint.js

@@ -0,0 +1,205 @@
+/**
+ * Copyright 2024 Contributors
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// All copies of this library in one process share this state.
+// Thus one route serves the files of every copy.
+// Shape: { registry: Map<nodeType, Set<path>>, routeRegistered: boolean }
+const shared = globalThis[Symbol.for('node-red-utils.resourceendpoint')] ??= {};
+shared.registry ??= new Map();
+shared.owners ??= new Map();        // nodeType -> name of the first package that registered it
+
+/** Name in the nearest package.json above a path, or null */
+function packageNameOf(resource) {
+    let dir = path.dirname(path.resolve(resource));
+    for (;;) {
+        try {
+            return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).name || null;
+        } catch (_) { /* no package.json here */ }
+        const parent = path.dirname(dir);
+        if (parent === dir) return null;
+        dir = parent;
+    }
+}
+
+/**
+ * Find the whitelisted file for a request, or return null.
+ * A registered file matches its base name only.
+ * A registered directory matches a file inside that directory only.
+ * @param {Set<string>} resources - Registered file and directory paths
+ * @param {string} requestPath - The decoded path after /<nodeType>/
+ * @returns {string|null}
+ */
+function findResource(resources, requestPath) {
+    for (const resource of resources) {
+        const root = path.resolve(resource);
+        let stat;
+        try { stat = fs.statSync(root); } catch (_) { continue; }
+
+        if (!stat.isDirectory()) {
+            if (path.basename(root) === requestPath) return root;
+            continue;
+        }
+
+        // Reject a path that resolves outside the registered directory
+        const candidate = path.resolve(root, requestPath);
+        if (!candidate.startsWith(root + path.sep)) continue;
+        try {
+            if (fs.statSync(candidate).isFile()) return candidate;
+        } catch (_) { /* not in this directory */ }
+    }
+    return null;
+}
+
+/**
+ * NodeRedResourceEndpoint - Class for registering and serving static resources
+ * Allows Node-RED nodes to serve static assets from a custom endpoint
+ */
+class NodeRedResourceEndpoint {
+
+    /**
+     * Create a new resource endpoint handler
+     * @param {object} RED - The Node-RED runtime instance
+     */
+    constructor(RED) {
+        this.RED = RED;
+
+        // Register the route only once per process
+        if (!shared.routeRegistered) {
+            shared.routeRegistered = true;
+            this._setupEndpoint();
+        }
+    }
+
+    /**
+     * Register resources for a node type
+     * @param {string} nodeType - The type identifier for the node
+     * @param {Array<string>|string} resources - File paths or directory paths to whitelist
+     * @returns {NodeRedResourceEndpoint} this object
+     */
+    registerResources(nodeType, resources) {
+        if (!Array.isArray(resources)) resources = [resources];
+        if (!shared.registry.has(nodeType)) shared.registry.set(nodeType, new Set());
+        const resourceSet = shared.registry.get(nodeType);
+        for (const resource of resources) {
+            if (resourceSet.has(resource)) continue;     // each node instance registers again
+            resourceSet.add(resource);
+            if (!fs.existsSync(resource)) {
+                this.RED.log.warn(`[NodeRedResourceEndpoint] Registered path does not exist: ${resource} (type ${nodeType})`);
+            }
+            const owner = packageNameOf(resource);
+            if (!shared.owners.has(nodeType)) shared.owners.set(nodeType, owner);
+            else if (owner && shared.owners.get(nodeType) && owner !== shared.owners.get(nodeType)) {
+                this.RED.log.warn(`[NodeRedResourceEndpoint] The packages "${shared.owners.get(nodeType)}" and "${owner}" ` +
+                    `both register files for "${nodeType}". Both are served under node-red-resourceendpoint/${nodeType}/; ` +
+                    `for the same file name, the first registered file wins.`);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Setup the HTTP endpoint to serve resources.
+     * Like the core /resources/ route of Node-RED, this route has no auth check:
+     * the editor loads these files with <script src>, which sends no token.
+     * @private
+     */
+    _setupEndpoint() {
+        this.RED.httpAdmin.get('/node-red-resourceendpoint/:nodeType/*', (req, res) => {
+            const nodeType = req.params.nodeType;
+            const requestPath = req.params[0];
+            const resources = shared.registry.get(nodeType);
+            const resourcePath = resources ? findResource(resources, requestPath) : null;
+
+            if (resourcePath) {
+                res.sendFile(resourcePath);
+            } else {
+                this.RED.log.warn(`[NodeRedResourceEndpoint] Resource not found: ${requestPath} for node type: ${nodeType}`);
+                res.sendStatus(404);
+            }
+        });
+    }
+}
+
+/**
+ * Mixin that adds resource endpoint capabilities to Node-RED nodes
+ * 
+ * Allows nodes to serve static assets from a custom endpoint
+ * Following the same functional mixin pattern used by NodeRedWorker
+ * 
+ * @param {class} superclass - The class to extend with resource endpoint capabilities
+ * @returns {class} A new class that extends the superclass with resource endpoint functionality
+ */
+const nodeRedResourceEndpoint = (superclass) => class extends superclass {
+    // Serve the `resources` of the createNode options before the first deploy
+    static onRegisterType(RED) {
+        super.onRegisterType?.(RED);
+        const { nodeType, resources } = this._registration || {};
+        if (resources !== undefined) new NodeRedResourceEndpoint(RED).registerResources(nodeType, resources);
+    }
+
+    constructor(RED, thisNode, config) {
+        super(RED, thisNode, config);
+        
+        // Create a namespaced object for resource endpoint functionality
+        this.nodeRedResourceEndpoint = {
+            /**
+             * Initialize the resource endpoint for this node
+             * @param {Object} [options] - Configuration options
+             * @param {string} [options.nodeType] - The type identifier for the node. If not provided, thisNode.type will be used
+             * @param {Array<string>|string} [options.resources] - File paths or directory paths to whitelist
+             * @returns {object} The resource endpoint interface
+             */
+            init: function(options = {}) {
+                // Use provided nodeType or fallback to thisNode.type
+                this._nodeType = options.nodeType || thisNode.type;
+                
+                // Get or create the static resource endpoint handler
+                if (!NodeRedResourceEndpoint._instance) {
+                    NodeRedResourceEndpoint._instance = new NodeRedResourceEndpoint(RED);
+                }
+                
+                this._parent.nodeRedResourceEndpoint = this;
+                
+                // Register resources if provided
+                if (options.resources !== undefined) {
+                    this.registerResources(options.resources);
+                }
+                
+                return this;
+            },
+
+            /**
+             * Register resources for a node type
+             * @param {Array<string>|string} resources - Array of file paths or directory paths to whitelist
+             */
+            registerResources: function(resources) {
+                if (!this._nodeType) {
+                    throw new Error('Resource endpoint must be initialized with a node type before registering resources');
+                }
+                
+                // Use the class instance to register resources
+                NodeRedResourceEndpoint._instance.registerResources(this._nodeType, resources);
+                return this;
+            },
+            
+            _nodeType: null,
+            _parent: this
+        };
+        thisNode.nodeRedResourceEndpoint = this.nodeRedResourceEndpoint;
+    }
+    
+    // Static property to hold the single instance
+    static _instance = null;
+};
+
+// Export both the class and the mixin
+module.exports.nodeRedResourceEndpoint = nodeRedResourceEndpoint;
+module.exports.NodeRedResourceEndpoint = NodeRedResourceEndpoint;