node-red-contrib-room-tools 1.9.3 → 1.9.5

package/control-panel.js

@@ -2,6 +2,7 @@ const crypto = require('node:crypto')
 const path = require('node:path')
 const { injectControlPolicy } = require('./control-policy')
 const { configuredRoutes, resolveBoundCommand, resolveBoundFeedback } = require('./control-bound-protocol')
+const { createDeviceAvailability } = require('./device-availability')
 const { catalogBase, listCatalogDevices, listCatalogTargets } = require('./control-catalog')
 const { contract } = require('./control-type-model')
 const { parseVisualBindings } = require('./panel-visual-bindings')
@@ -142,6 +143,7 @@ module.exports = function (RED) {
       }
     }
 
+    const availability = createDeviceAvailability(routes)
     let bridgeReady = !config.bridgeRevisionApplied
     if (config.nativeBridge === true) {
       try {
@@ -174,6 +176,10 @@ module.exports = function (RED) {
 
     let gateway
     let gatewayAuthKey
+    async function telemetryTicket (req, res, identity, active) {
+      if (await meter?.ticket(req, res, identity, active)) return true
+      return await xySeries?.ticket(req, res, identity, active) || false
+    }
     const momentary = createMomentaryControls({ routes,
       send: (command, identity) => node.send({ ...command, room: identity.room, user: identity.user }),
       onError: error => node.error(error) })
@@ -189,11 +195,13 @@ module.exports = function (RED) {
           holdEpoch: momentary.epoch,
           secureCookie: config.secureCookie === true,
           restoredSessions: takeSessions(gatewayHandoffs, node.id, gatewayAuthKey),
-          onAuthenticatedRequest: (req, res, identity) => meter?.ticket(req, res, identity,
-            () => gateway?.sessionActive(identity.token)) || xySeries?.ticket(req, res, identity,
-              () => gateway?.sessionActive(identity.token)) || false,
+          onAuthenticatedRequest: (req, res, identity) => telemetryTicket(req, res, identity,
+            () => gateway?.sessionActive(identity.token)),
           onBoundCommand: (message, identity) => {
             if (!bridgeReady) return false
+            if (message?._controlPanel?.hold?.action !== 'release' && !availability.allowed(message?._controlPanel?.id)) {
+              throw Error('Device is unavailable')
+            }
             if (message?._controlPanel?.hold) return momentary.handle(message, identity)
             const command = resolveBoundCommand(routes, message)
             if (routes.get(command.controlId)?.control.buttonBehavior === 'momentary' || momentary.isHeld(command)) {
@@ -207,6 +215,7 @@ module.exports = function (RED) {
             try { node.send({ kind: 'read-all', room: identity.room, user: identity.user }) } catch (error) { node.error(error) }
           }
         })
+        gateway.boundAvailability(availability.snapshot())
         activePanels.set(node.id, gateway)
       } catch (error) {
         node.error(error)
@@ -226,11 +235,10 @@ module.exports = function (RED) {
         password: node.credentials?.editorPassword,
         secureCookie: config.secureCookie === true,
         restoredSessions: takeSessions(editorHandoffs, node.id, editorAuthKey),
-        onAuthenticatedRequest: (req, res, identity) => meter?.ticket(req, res, identity,
-          () => editor?.sessionActive(identity.token)) || xySeries?.ticket(req, res, identity,
-            () => editor?.sessionActive(identity.token)) || false,
+        onAuthenticatedRequest: (req, res, identity) => telemetryTicket(req, res, identity,
+          () => editor?.sessionActive(identity.token)),
         getConfig: async req => editorConfig(await getSnapshot(req.socket.localPort, fetch,
-          RED.settings.httpAdminRoot ?? '/'), node.id),
+          RED.settings.httpAdminRoot ?? '/', { maxAgeMs: 5000, allowStaleMs: 60000 }), node.id),
         getDevices: async () => {
           if (!base) throw new Error('Device catalog unavailable')
           return listCatalogDevices(base)
@@ -247,7 +255,8 @@ module.exports = function (RED) {
             userDir: RED.settings.userDir,
             localPort: req.socket.localPort,
             adminRoot: RED.settings.httpAdminRoot ?? '/',
-            catalogBase: base
+            catalogBase: base,
+            editorCookie: req.headers.cookie
           })
       })
       if (editor) activeEditors.set(node.id, editor)
@@ -269,6 +278,22 @@ module.exports = function (RED) {
       ...((meter || xySeries) ? { onSocket: { ...(meter?.hooks || {}), ...(xySeries?.hooks || {}) } } : {}),
       beforeSend (msg) {
         if (msg?._controlPanel?.kind === 'command') throw new Error('Bound commands require authenticated HTTP')
+        if (msg?.kind === 'device-availability') {
+          if (bridgeReady && gateway) {
+            const items = availability.update(msg)
+            if (items) {
+              for (const item of items) if (!item.available) momentary.releaseControl(item.id)
+              const pending = availability.takePending()
+              if (pending.length) gateway.boundFeedback(pending)
+              const changed = availability.changes()
+              if (changed) gateway.boundAvailability(changed)
+              // Re-read exported real state after readiness; no browser refresh,
+              // no Deploy and no periodic catalog requests.
+              if (msg.payload === true || msg.payload === 'true') node.send({ kind: 'read-all', room: boundRoom })
+            }
+          }
+          return false
+        }
         if (['device-meter-frame', 'device-meter-manifest'].includes(msg?.kind)) {
           if (bridgeReady) meter?.accept(msg)
           // Dashboard 1.31 reads properties before checking whether a message
@@ -281,7 +306,10 @@ module.exports = function (RED) {
         }
         if (boundMode) {
           if (msg?.kind === 'device-feedback' && gateway) {
-            gateway.boundFeedback(resolveBoundFeedback(routes, msg))
+            const items = availability.feedback(resolveBoundFeedback(routes, msg))
+            if (items.length) gateway.boundFeedback(items)
+            const changed = availability.changes()
+            if (changed) gateway.boundAvailability(changed)
           }
           return {}
         }

package/control-policy.js

@@ -194,6 +194,7 @@ export default {
       boundUnconfirmed: {},
       boundFeedbackRevision: 0,
       boundFeedbackConnected: false,
+      boundAvailability: {},
       boundAuthenticated: false,
     }
   },
@@ -211,11 +212,28 @@ export default {
     __boundControl (id) {
       return this.__boundControls().find(control => control.id === id)
     },
+    __deviceAvailable (id) {
+      const binding = this.__boundPanelConfig()?.visual?.bindings?.[id]
+      if (!binding?.readMeta?.availability && !binding?.writeMeta?.availability) return true
+      return this.boundFeedbackConnected && this.boundAvailability[id] === true
+    },
     applyBoundFeedback (message) {
+      if (message?.kind === 'bound-availability') {
+        if (message.room !== this.__boundPanelConfig()?.room || !Array.isArray(message.availability) ||
+          !Number.isInteger(message.revision) || message.revision < this.boundFeedbackRevision) return false
+        this.boundFeedbackRevision = message.revision
+        this.boundAvailability = Object.fromEntries(message.availability.filter(item =>
+          typeof item?.id === 'string' && typeof item.available === 'boolean').map(item => [item.id, item.available]))
+        for (const [id, available] of Object.entries(this.boundAvailability)) if (!available) this.__clearBoundPending(id)
+        return true
+      }
       if (['bound-snapshot', 'bound-feedback'].includes(message?.kind)) {
         if (message.room !== this.__boundPanelConfig()?.room || !Array.isArray(message.items) ||
           !Number.isInteger(message.revision) || message.revision < this.boundFeedbackRevision) return false
-        if (message.kind === 'bound-snapshot') this.boundState = {}
+        if (message.kind === 'bound-snapshot') {
+          this.boundState = {}
+          this.boundAvailability = Object.fromEntries((message.availability || []).map(item => [item.id, item.available === true]))
+        }
         this.boundFeedbackRevision = message.revision
         return message.items.map(item => this.applyBoundFeedback({
           __boundRevision: message.revision,
@@ -279,6 +297,7 @@ export default {
       const control = this.__boundControl(id)
       if (!control) throw new Error('Unknown control ID: ' + id)
       if (control.mode === 'read') throw new Error('Read-only control: ' + id)
+      if (!this.__deviceAvailable(id)) throw new Error('Device is unavailable')
       if (!Object.prototype.hasOwnProperty.call(command, 'value')) throw new Error('Bound control needs a value')
       if (!this.__boundPanelSession?.csrf) throw new Error('Bound panel login required')
       const previous = this.__boundSettlements.get(id)
@@ -351,6 +370,7 @@ export default {
       this.__boundPanelSource?.close()
       this.__boundPanelSource = null
       this.boundFeedbackConnected = false
+      this.boundAvailability = {}
     },
     __connectBoundFeedback () {
       this.__closeBoundFeedback()
@@ -369,7 +389,12 @@ export default {
         }
       }
       source.onerror = () => {
-        if (this.__boundPanelSource === source) this.boundFeedbackConnected = false
+        if (this.__boundPanelSource === source) {
+          this.boundFeedbackConnected = false
+          this.boundAvailability = {}
+          this.__resetControlPolicy()
+          this.__clearAllBoundSettlements()
+        }
       }
     },
     setBoundPanelSession (session) {
@@ -412,7 +437,7 @@ export default {
       this.setBoundPanelSession(session)
       return session
     },
-    async restoreBoundPanelSession (timeoutMs = 2500) {
+    async restoreBoundPanelSession (timeoutMs = 12000) {
       const config = this.__boundPanelConfig()
       if (!config) return null
       const generation = this.__boundAuthGeneration
@@ -421,8 +446,11 @@ export default {
       }, timeoutMs, async response => ({ response, session: response.ok ? await response.json() : null }))
       if (generation !== this.__boundAuthGeneration) return this.__boundPanelSession
       if (!response.ok) {
-        this.clearBoundPanelSession()
-        return null
+        if (response.status === 401) {
+          this.clearBoundPanelSession()
+          return null
+        }
+        throw new Error('Panel session unavailable (' + response.status + ')')
       }
       if (generation !== this.__boundAuthGeneration) return this.__boundPanelSession
       this.setBoundPanelSession(session)
@@ -450,6 +478,7 @@ export default {
       const session = this.__boundPanelSession;
       if (!config || !session)
         throw new Error('Bound panel login required');
+      if (!this.__deviceAvailable(command.controlKey)) throw new Error('Device is unavailable');
       const response = await this.__panelFetch(config.endpoint + '/bound-command', {
         method: 'POST',
         credentials: 'same-origin',

package/control-type-model.js

@@ -1,14 +1,58 @@
 const contract = require('./control-type-contract.json')
 const { meterRoute } = require('./meter-route')
-
-
-
 // Used by both server validation and the injected editor; keep it self-contained.
 function createTargetMatcher (typeContract) {
   const families = {
     range: ['number'], switch: ['boolean'], meter: ['number'], 'xy-series': ['xy-series'],
     'text-display': ['text', 'number', 'enum', 'boolean'], 'text-input': ['text'], select: ['enum']
   }
+  function modes (adapter) {
+    if (!families[adapter]) return []
+    return ['meter', 'xy-series', 'text-display'].includes(adapter)
+      ? ['read'] : ['both', 'write', 'read']
+  }
+  function states (target) {
+    if (target.meter || target.xySeries || !['boolean', 'integer', 'float', 'enum', 'string', 'dstring'].includes(target.type)) return null
+    if (Array.isArray(target.enums) && target.enums.length) {
+      if (target.enums.length !== 2) return null
+      const values = target.enums.map(entry => entry && typeof entry === 'object' ? entry.value : entry)
+      if (values.some(value => !['boolean', 'string', 'number'].includes(typeof value) ||
+        (typeof value === 'number' && !Number.isFinite(value))) || values[0] === values[1]) return null
+      if (target.type === 'integer' && values.some(value => !Number.isSafeInteger(value))) return null
+      if (target.type === 'float' && values.some(value => typeof value !== 'number')) return null
+      if (target.type === 'boolean' && values.some(value => typeof value !== 'boolean')) return null
+      if (['string', 'dstring'].includes(target.type) && values.some(value => typeof value !== 'string')) return null
+      return values
+    }
+    if (target.type === 'boolean') return [false, true]
+    if (target.type === 'integer' && Number.isSafeInteger(target.min) &&
+      Number.isSafeInteger(target.max) && target.max - target.min === 1) return [target.min, target.max]
+    return null
+  }
+  // Native readonly numeric parameters need no custom frame/manifest route.
+  function meterTarget (target) {
+    return target.access === 'ro' && !target.xySeries &&
+      ['integer', 'float'].includes(target.type) &&
+      Boolean(target.meter || (!target.enums?.length && !states(target)))
+  }
+  function reverse (binding = {}, write = binding.writeMeta, read = binding.readMeta) {
+    if (Object.hasOwn(binding, 'stateReverse')) {
+      if (typeof binding.stateReverse !== 'boolean') throw new Error('State reverse must be boolean')
+      return binding.stateReverse
+    }
+    const point = write || read
+    const mapping = write
+      ? (Object.hasOwn(binding, 'writeMapping') ? binding.writeMapping : binding.writeMeta?.booleanMapping)
+      : (Object.hasOwn(binding, 'readMapping') ? binding.readMapping : binding.readMeta?.booleanMapping)
+    if (mapping === undefined) return false
+    const values = point && states(point)
+    if (!values || !mapping || typeof mapping !== 'object' || Array.isArray(mapping) ||
+      !Object.hasOwn(mapping, 'falseValue') || !Object.hasOwn(mapping, 'trueValue') ||
+      Object.is(mapping.falseValue, mapping.trueValue) ||
+      !values.some(value => Object.is(value, mapping.falseValue)) ||
+      !values.some(value => Object.is(value, mapping.trueValue))) throw new Error('Invalid two-state mapping')
+    return Object.is(mapping.trueValue, values[0])
+  }
   function family (target) {
     if (target.xySeries) return 'xy-series'
     if (target.controlSchemaVersion !== typeContract.schemaVersion) return null
@@ -24,28 +68,43 @@ function createTargetMatcher (typeContract) {
     return definition.family
   }
   function compatible (adapter, target, direction, candidate = {}) {
-    if (adapter === 'meter' && !target.meter) return false
+    if (adapter === 'meter' && !meterTarget(target)) return false
+    if (adapter === 'range' && meterTarget(target)) return false
     if (adapter === 'xy-series' && !target.xySeries) return false
     if (target.meter && (adapter !== 'meter' || direction !== 'read' || target.access !== 'ro')) return false
     if (target.xySeries && (adapter !== 'xy-series' || direction !== 'read' || target.access !== 'ro')) return false
-    if (target.kind !== 'param' || !families[adapter]?.includes(family(target))) return false
+    if (target.kind !== 'param' || !(adapter === 'switch'
+      ? states(target) : families[adapter]?.includes(family(target)))) return false
     if (direction === 'write' && ['meter', 'xy-series', 'text-display'].includes(adapter)) return false
     if (!['read', 'write'].includes(direction)) return false
     if (!(direction === 'write' ? ['wo', 'rw'] : ['ro', 'rw']).includes(target.access)) return false
     if (candidate.unit && candidate.unit !== target.unit) return false
     return true
   }
-  return { family, compatible }
+  return { family, compatible, modes, states, reverse, meterTarget }
 }
 
-const { family: targetFamily, compatible: compatibleTarget } = createTargetMatcher(contract)
+const { family: targetFamily, compatible: compatibleTarget, modes: bindingModes, states: targetStates, reverse: stateReverse, meterTarget: isMeterTarget } = createTargetMatcher(contract)
+
+function switchMapping (target, mapping, reverse = false) {
+  const states = targetStates(target)
+  if (!states) throw new Error('Switch target must describe exactly two distinct states')
+  const result = mapping === undefined ? { falseValue: states[reverse ? 1 : 0], trueValue: states[reverse ? 0 : 1] } : mapping
+  if (!result || typeof result !== 'object' || Array.isArray(result) ||
+    !Object.hasOwn(result, 'falseValue') || !Object.hasOwn(result, 'trueValue') ||
+    Object.is(result.falseValue, result.trueValue) ||
+    !states.some(value => Object.is(value, result.falseValue)) ||
+    !states.some(value => Object.is(value, result.trueValue))) throw new Error('Invalid two-state mapping')
+  return { falseValue: result.falseValue, trueValue: result.trueValue }
+}
 
 function controlTypeForAdapter (adapter, target) {
   if (!compatibleTarget(adapter, target, 'read') && !compatibleTarget(adapter, target, 'write')) {
     throw new Error('Target is incompatible with this control')
   }
-  if (adapter === 'meter' && target.meter) return 'meter'
+  if (adapter === 'meter') return 'meter'
   if (adapter === 'xy-series' && target.xySeries) return 'xy-series'
+  if (adapter === 'switch') return 'mute'
   const family = targetFamily(target)
   if (family === 'number') return 'level'
   if (family === 'boolean') return 'mute'
@@ -54,7 +113,7 @@ function controlTypeForAdapter (adapter, target) {
   throw new Error('Unsupported control family')
 }
 
-function targetMeta (target, onebased) {
+function targetMeta (target, onebased, booleanMapping) {
   if (typeof target.onebased !== 'boolean' && typeof onebased !== 'boolean') {
     throw new Error('Select target numbering mode')
   }
@@ -63,10 +122,13 @@ function targetMeta (target, onebased) {
     onebased: typeof target.onebased === 'boolean' ? target.onebased : onebased,
     min: target.min, max: target.max, enums: target.enums,
     ...(target.booleanEncoding ? { booleanEncoding: target.booleanEncoding } : {}),
+    ...(booleanMapping ? { booleanMapping: switchMapping(target, booleanMapping) } : {}),
     controlType: target.controlType, controlSchemaVersion: target.controlSchemaVersion,
     ...(target.meter ? { meter: meterRoute(target.meter), unit: target.unit || '' } : {}),
-    ...(target.xySeries ? { xySeries: require('./xy-series-route').xySeriesRoute(target.xySeries) } : {})
+    ...(target.xySeries ? { xySeries: require('./xy-series-route').xySeriesRoute(target.xySeries) } : {}),
+    ...(target.availability ? { availability: require('./device-availability').availabilityRoute(target.availability,
+      typeof target.onebased === 'boolean' ? target.onebased : onebased) } : {})
   }
 }
 
-module.exports = { contract, createTargetMatcher, compatibleTarget, controlTypeForAdapter, targetFamily, targetMeta }
+module.exports = { contract, createTargetMatcher, compatibleTarget, controlTypeForAdapter, targetFamily, targetMeta, bindingModes, targetStates, switchMapping, stateReverse, isMeterTarget }

package/device-availability.js

@@ -0,0 +1,104 @@
+function availabilityRoute (value, onebased) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw Error('Invalid device availability route')
+  const result = {}
+  for (const role of ['online', 'ready']) {
+    const point = value[role]
+    if (!point && role === 'ready') continue
+    if (!point || typeof point.path !== 'string' || !/^\/\/[^\s]{1,1024}$/.test(point.path) ||
+      (typeof point.onebased !== 'boolean' && typeof onebased !== 'boolean')) throw Error('Invalid ' + role + ' availability point')
+    result[role] = { path: point.path, onebased: point.onebased ?? onebased }
+  }
+  return result
+}
+
+function createDeviceAvailability (routes) {
+  const groups = new Map()
+  const controls = new Map()
+  const needsFeedback = new Set()
+  const fresh = new Set()
+  for (const [id, { binding, control }] of routes) {
+    const keys = new Set()
+    for (const meta of [binding.readMeta, binding.writeMeta]) {
+      if (!meta?.availability) continue
+      const route = availabilityRoute(meta.availability)
+      const key = JSON.stringify([binding.device, route])
+      if (!groups.has(key)) groups.set(key, { device: binding.device, route, online: false, ready: false })
+      keys.add(key)
+    }
+    if (keys.size) {
+      controls.set(id, [...keys])
+      if (control.mode !== 'write' && !binding.readMeta?.meter && !binding.readMeta?.xySeries) needsFeedback.add(id)
+    }
+  }
+  const pending = new Map()
+  const healthy = id => !controls.has(id) || controls.get(id).every(key => {
+    const group = groups.get(key)
+    return group.online === true && (!group.route.ready || group.ready === true)
+  })
+  const allowed = id => healthy(id) && (!needsFeedback.has(id) || fresh.has(id))
+  const snapshot = () => [...controls.keys()].map(id => ({ id, available: allowed(id) }))
+  let previous = JSON.stringify(snapshot())
+  let dirty = false
+  return {
+    allowed,
+    snapshot,
+    changes () {
+      if (!dirty) return null
+      dirty = false
+      const items = snapshot()
+      const next = JSON.stringify(items)
+      if (next === previous) return null
+      previous = next
+      return items
+    },
+    update (message) {
+      if (message?.kind !== 'device-availability') return null
+      const value = message.payload === true || message.payload === 'true' ? true
+        : message.payload === false || message.payload === 'false' ? false : null
+      if (value === null) return null
+      let changed = false
+      for (const group of groups.values()) {
+        if (group.device !== message.device) continue
+        for (const role of ['online', 'ready']) {
+          if (group.route[role]?.path !== message.path) continue
+          if (group[role] !== value) changed = true
+          group[role] = value
+          if (role === 'online' && !value) group.ready = false
+        }
+      }
+      if (!changed) return null
+      dirty = true
+      for (const id of controls.keys()) if (!healthy(id)) {
+        fresh.delete(id)
+        if (!controls.get(id).every(key => groups.get(key).online)) pending.delete(id)
+      }
+      return snapshot()
+    },
+    feedback (items) {
+      const result = []
+      for (const item of items) {
+        if (healthy(item.id)) {
+          if (controls.has(item.id) && !fresh.has(item.id)) { fresh.add(item.id); dirty = true }
+          result.push(item)
+        }
+        else {
+          // Fresh initialization replies may arrive before stateReady=true.
+          // Never retain values received while the transport is offline.
+          if (controls.get(item.id)?.every(key => groups.get(key).online)) pending.set(item.id, item)
+        }
+      }
+      return result
+    },
+    takePending () {
+      const result = []
+      for (const [id, item] of pending) if (healthy(id)) {
+        if (!fresh.has(id)) { fresh.add(id); dirty = true }
+        result.push(item)
+        pending.delete(id)
+      }
+      return result
+    }
+  }
+}
+
+module.exports = { availabilityRoute, createDeviceAvailability }

package/gateway.cjs

@@ -47,15 +47,24 @@ function createGateway ({
   let closed = false
   let heartbeatTimer = null
 
-  function closeSubscriber (subscriber) {
-    subscribers.delete(subscriber)
-    try { subscriber.res.end() } catch (_) {}
+  function closeSubscriber (subscriber, destroy = false) {
+    if (!subscribers.delete(subscriber)) return
+    try { if (destroy) subscriber.res.destroy(); else subscriber.res.end() } catch (_) {}
     if (!subscribers.size && heartbeatTimer) {
       clearInterval(heartbeatTimer)
       heartbeatTimer = null
     }
   }
 
+  function writeSubscriber (subscriber, data) {
+    try {
+      // Allow one queued write to drain, including a large initial snapshot.
+      // A persistently blocked client reconnects to the latest snapshot.
+      if (subscriber.blocked) return closeSubscriber(subscriber, true)
+      if (subscriber.res.write(data) === false) subscriber.blocked = true
+    } catch (_) { closeSubscriber(subscriber, true) }
+  }
+
   function ensureHeartbeat () {
     if (heartbeatTimer || !subscribers.size) return
     heartbeatTimer = setInterval(() => {
@@ -68,23 +77,21 @@ function createGateway ({
           closeSubscriber(subscriber)
           continue
         }
-        try { subscriber.res.write(': heartbeat\n\n') } catch (_) { closeSubscriber(subscriber) }
+        writeSubscriber(subscriber, ': heartbeat\n\n')
       }
     }, FEEDBACK_HEARTBEAT_MS)
     heartbeatTimer.unref?.()
   }
 
   function sendFeedbackEvent (subscriber, message) {
-    try {
-      subscriber.res.write('data: ' + JSON.stringify(message) + '\n\n')
-    } catch (_) {
-      closeSubscriber(subscriber)
-    }
+    writeSubscriber(subscriber, 'data: ' + JSON.stringify(message) + '\n\n')
   }
 
 
   function broadcastFeedback (message) {
-    for (const subscriber of [...subscribers]) sendFeedbackEvent(subscriber, message)
+    if (!subscribers.size) return
+    const data = 'data: ' + JSON.stringify(message) + '\n\n'
+    for (const subscriber of [...subscribers]) writeSubscriber(subscriber, data)
   }
 
   function closeSubscribersForToken (token) {
@@ -107,11 +114,22 @@ function createGateway ({
     return message
   }
 
+  let availability = []
+  function boundAvailability (items) {
+    if (!Array.isArray(items) || items.some(item => typeof item?.id !== 'string' || typeof item.available !== 'boolean')) {
+      throw Error('Invalid bound availability')
+    }
+    availability = items.map(item => ({ id: item.id, available: item.available }))
+    boundRevision++
+    broadcastFeedback({ room, kind: 'bound-availability', availability, revision: boundRevision })
+  }
+
   function boundSnapshot () {
     return {
       room, kind: 'bound-snapshot',
       items: [...boundState].map(([id, value]) => ({ id, value })),
-      revision: boundRevision
+      revision: boundRevision,
+      ...(availability.length ? { availability } : {})
     }
   }
 
@@ -205,6 +223,10 @@ function createGateway ({
         return true
       }
       if (path === routePrefix + '/events' && req.method === 'GET') {
+        if (subscribers.size >= 100) {
+          reply(res, 503, { error: 'Feedback connection limit reached' })
+          return true
+        }
         res.writeHead(200, {
           'Content-Type': 'text/event-stream; charset=utf-8',
           'Cache-Control': 'no-cache, no-transform',
@@ -213,8 +235,9 @@ function createGateway ({
           'X-Content-Type-Options': 'nosniff'
         })
         res.flushHeaders?.()
-        const subscriber = { res, token }
+        const subscriber = { res, token, blocked: false }
         subscribers.add(subscriber)
+        res.on('drain', () => { subscriber.blocked = false })
         res.on('close', () => closeSubscriber(subscriber))
         sendFeedbackEvent(subscriber, boundSnapshot())
         ensureHeartbeat()
@@ -264,6 +287,7 @@ function createGateway ({
   return {
     handler,
     boundFeedback,
+    boundAvailability,
     sessionActive: token => !closed && (sessions.get(token)?.expiry || 0) > Date.now(),
     sessionSnapshot () {
       return new Map([...sessions].filter(([, session]) => session.expiry > Date.now())

package/managed-native-bridge.js

@@ -24,9 +24,11 @@ function panelTargets (panel) {
       const target = {
         device: binding.device, path, kind: meta.kind, type: meta.type,
         access: meta.access, onebased: meta.onebased,
+        min: meta.min, max: meta.max, enums: meta.enums,
         ...(meta.booleanEncoding ? { booleanEncoding: meta.booleanEncoding } : {}),
         ...(meta.meter ? { meter: meta.meter } : {}),
-        ...(meta.xySeries ? { xySeries: meta.xySeries } : {})
+        ...(meta.xySeries ? { xySeries: meta.xySeries } : {}),
+        ...(meta.availability ? { availability: meta.availability } : {})
       }
       const key = JSON.stringify([target.device, target.path])
       const previous = targets.get(key)

package/meter-frame.js

@@ -99,7 +99,13 @@ function createRoomMeterReceiver (layout) {
         frame.valid.some((flag, index) => typeof flag !== 'boolean' || (flag
           ? typeof frame.values[index] !== 'number' || !Number.isFinite(frame.values[index])
           : frame.values[index] !== null))) return false
-      latest = { values: frame.values.slice(), valid: frame.valid.slice(), seq: frame.seq }
+      if (frame.sources !== undefined && (!Array.isArray(frame.sources) || frame.sources.length > 256 ||
+        frame.sources.some(source => typeof source?.device !== 'string' || source.device.length > 128 ||
+          typeof source.streamId !== 'string' || source.streamId.length > 128 ||
+          typeof source.epoch !== 'string' || source.epoch.length > 128 ||
+          !Number.isSafeInteger(source.seq) || source.seq < 0))) return false
+      latest = { values: frame.values.slice(), valid: frame.valid.slice(), seq: frame.seq,
+        ...(frame.sources ? { sources: frame.sources.map(({ device, streamId, epoch, seq }) => ({ device, streamId, epoch, seq })) } : {}) }
       pending = true
       return true
     },