feat(peripheral-demo): add Edge App for peripheral integration

[nicomiguelino]

Summary

• Add peripheral-integration-demo Edge App demonstrating multi-screen role-based display (public, operator, maintenance) driven by live peripheral data
• Add createPeripheralClient() to edge-apps-library — a WebSocket client that connects to the hardware integration service and delivers sensor state via watchState(callback)
• Add startPeripheralMockServer() to the Vite dev-server plugin, simulating the peripheral WebSocket protocol on port 9010 for local development
• Wire ambient temperature readings into the public screen display
• Wire NFC card reads into role-based screen switching
• Add SourceChannelStateReport and EdgeAppSourceState types to edge-apps-library
• Exclude font files from asset inlining to prevent false positives during deployment

Notes

• The WebSocket connection is lazy — it only starts when register() or watchState() is first called, so existing apps in dev mode are unaffected
• If port 9010 is already in use (e.g. real hardware is connected), the mock server silently skips startup
• Font assets are now emitted as separate files; other assets (e.g. images) continue to be inlined up to 7 MB

Screenshots

[github-actions]

PR Reviewer Guide 🔍

(Review updated until commit ab7323a)

Here are some key observations to aid the review process:

⏱️ Estimated effort to review: 4 🔵🔵🔵🔵⚪

🧪 PR contains tests

🔒 No security concerns identified

⚡ Recommended focus areas for review Protocol Robustness The WebSocket framing/parsing looks optimistic: messages are trimmed with a single ETB replace and then JSON-parsed, which may fail if multiple frames arrive in one event, if ETB appears more than once, or if partial frames are received. Consider a small frame buffer/split-on-ETB approach (and using a safer trim like removing only trailing ETB), plus validating expected shapes before accessing nested properties like request IDs and state arrays. function send(payload: unknown) { if (ws && ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(payload) + ETB) } } function notifySubscribers() { const msg: PeripheralStateMessage = { request: { id: ulid(), edge_app_source_state: { states: Object.values( readings, ) as PeripheralStateMessage['request']['edge_app_source_state']['states'], }, }, } subscribers.forEach((cb) => cb(msg)) } function connect() { ws = new WebSocket(PERIPHERAL_WS_URL) ws.onopen = () => { send({ request: { id: ulid(), identification: { node_id: ulid(), description: 'Edge App' }, }, }) } ws.onmessage = (e: MessageEvent) => { const text = (e.data as string).replace(ETB, '') let msg: Record<string, unknown> try { msg = JSON.parse(text) as Record<string, unknown> } catch { return } const response = msg.response as Record<string, unknown> | undefined if ( response?.ok !== undefined && (response.ok as Record<string, unknown>)?.identification !== undefined ) { identified = true return } const request = msg.request as Record<string, unknown> | undefined if (request?.edge_app_source_state) { const state = request.edge_app_source_state as { states: Array<{ name: string }> } state.states.forEach((s) => { readings[s.name] = s }) notifySubscribers() send({ response: { request_id: request.id, ok: 'edge_app_source_state' }, }) return } if (request?.downstream_node_event) { send({ response: { request_id: request.id, ok: 'downstream_node_event' }, }) return } } Lifecycle Leak Subscriber management has no unsubscribe and the internal subscribers array can grow unbounded (especially across screen/app re-inits). Also, register adds a message event listener per call until identification completes; repeated calls before identification could accumulate listeners. It would be safer to return an unsubscribe function from watchState, dedupe callbacks, and ensure one-time listeners are truly one-time even under reconnects. // eslint-disable-next-line max-lines-per-function export function createPeripheralClient(): PeripheralClient { let ws: WebSocket | null = null let identified = false const subscribers: Array<(msg: PeripheralStateMessage) => void> = [] const readings: Record<string, unknown> = {} function send(payload: unknown) { if (ws && ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(payload) + ETB) } } function notifySubscribers() { const msg: PeripheralStateMessage = { request: { id: ulid(), edge_app_source_state: { states: Object.values( readings, ) as PeripheralStateMessage['request']['edge_app_source_state']['states'], }, }, } subscribers.forEach((cb) => cb(msg)) } function connect() { ws = new WebSocket(PERIPHERAL_WS_URL) ws.onopen = () => { send({ request: { id: ulid(), identification: { node_id: ulid(), description: 'Edge App' }, }, }) } ws.onmessage = (e: MessageEvent) => { const text = (e.data as string).replace(ETB, '') let msg: Record<string, unknown> try { msg = JSON.parse(text) as Record<string, unknown> } catch { return } const response = msg.response as Record<string, unknown> | undefined if ( response?.ok !== undefined && (response.ok as Record<string, unknown>)?.identification !== undefined ) { identified = true return } const request = msg.request as Record<string, unknown> | undefined if (request?.edge_app_source_state) { const state = request.edge_app_source_state as { states: Array<{ name: string }> } state.states.forEach((s) => { readings[s.name] = s }) notifySubscribers() send({ response: { request_id: request.id, ok: 'edge_app_source_state' }, }) return } if (request?.downstream_node_event) { send({ response: { request_id: request.id, ok: 'downstream_node_event' }, }) return } } ws.onerror = () => console.warn('[screenly] Peripheral WS error') ws.onclose = () => { identified = false setTimeout(connect, 2000) } } return { register(edgeAppId: string) { if (!ws) connect() const sendRegistration = () => { send({ request: { id: ulid(), edge_app_registration: { id: edgeAppId, secret: '', requested_source_channels: [], }, }, }) } if (ws!.readyState === WebSocket.OPEN && identified) { sendRegistration() } else { ws!.addEventListener('message', function onIdentified() { if (identified) { sendRegistration() ws!.removeEventListener('message', onIdentified) } }) } }, watchState(callback: (msg: PeripheralStateMessage) => void) { if (!ws) connect() subscribers.push(callback) }, } Dev WS Behavior startPeripheralMockServer() is started unconditionally and logs “listening” even if the port is already in use; depending on how ws behaves, this can produce misleading output. Also the comment says “every 5 seconds” but the interval is 10s, and intervals/servers aren’t tied into Vite server shutdown hooks (potential port contention on rapid restarts). Consider gating the startup, logging only after successful listen, and cleaning up on server close. const PERIPHERAL_WS_PORT = 9010 const ETB = '\x17' type SensorType = | 'ambient_temperature' | 'humidity' | 'air_pressure' | 'secure_card' const SENSOR_META: Record< SensorType, { channelName: string; unit: string | null } > = { ambient_temperature: { channelName: 'my_living_room_temp', unit: '°C' }, humidity: { channelName: 'room_humidity', unit: '%' }, air_pressure: { channelName: 'room_pressure', unit: 'hPa' }, secure_card: { channelName: 'ew_demo_nfc_reader', unit: null }, } const MOCK_CARD_UIDS = { operator: 'yHSl7w', maintenance: 'mK3pXq', } function makeMockSensorValue( sensor: SensorType, ): number | Record<string, string> { switch (sensor) { case 'ambient_temperature': return parseFloat((20 + Math.random() * 10).toFixed(2)) case 'humidity': return parseFloat((40 + Math.random() * 40).toFixed(2)) case 'air_pressure': return parseFloat((1000 + Math.random() * 30).toFixed(2)) case 'secure_card': return { uid: Math.random() < 0.5 ? MOCK_CARD_UIDS.operator : MOCK_CARD_UIDS.maintenance, } } } function buildStateSnapshot(): Record<string, unknown>[] { return ( Object.entries(SENSOR_META) as [ SensorType, { channelName: string; unit: string | null }, ][] ).map(([wireKey, meta]) => { const reading: Record<string, unknown> = { name: meta.channelName, [wireKey]: makeMockSensorValue(wireKey), timestamp: Date.now(), } if (meta.unit) reading.unit = meta.unit return reading }) } // eslint-disable-next-line max-lines-per-function function startPeripheralMockServer(): void { const wss = new WebSocketServer({ port: PERIPHERAL_WS_PORT }) // eslint-disable-next-line max-lines-per-function wss.on('connection', (ws) => { let identified = false ws.on('message', (raw: Buffer) => { const text = raw.toString().replace(ETB, '') let msg: Record<string, unknown> try { msg = JSON.parse(text) } catch { return } const req = msg.request as Record<string, unknown> | undefined if (!req) return const requestId = req.id as string // Identification handshake if (req.identification) { identified = true const ack = JSON.stringify({ response: { request_id: requestId, ok: { identification: null } }, }) + ETB ws.send(ack) // Push full state snapshot immediately after identification const initialSnapshot = JSON.stringify({ request: { id: ulid(), edge_app_source_state: { states: buildStateSnapshot() }, }, }) + ETB ws.send(initialSnapshot) return } if (!identified) return // Registration is fire-and-forget — no response needed if (req.edge_app_registration) return // GetState request const channelName = req.source_channel_get_state as string | undefined const sensorEntry = channelName ? ( Object.entries(SENSOR_META) as [ SensorType, { channelName: string; unit: string | null }, ][] ).find(([, meta]) => meta.channelName === channelName) : undefined if (sensorEntry) { const [wireKey, meta] = sensorEntry const value = makeMockSensorValue(wireKey) const reading: Record<string, unknown> = { name: channelName, [wireKey]: value, timestamp: Date.now(), } if (meta.unit) reading.unit = meta.unit const response = JSON.stringify({ response: { request_id: requestId, ok: { source_channel_get_state: reading }, }, }) + ETB ws.send(response) } }) // Push full state snapshot every 5 seconds const interval = setInterval(() => { if (!identified || ws.readyState !== ws.OPEN) return const event = JSON.stringify({ request: { id: ulid(), edge_app_source_state: { states: buildStateSnapshot() }, }, }) + ETB ws.send(event) }, 10000) ws.on('close', () => clearInterval(interval)) }) wss.on('error', (err: NodeJS.ErrnoException) => { if (err.code === 'EADDRINUSE') { console.warn( `[screenly-dev-server] Port ${PERIPHERAL_WS_PORT} already in use — peripheral mock not started.`, ) } else { console.error('[screenly-dev-server] Peripheral WS error:', err.message) } }) console.log( `[screenly-dev-server] Peripheral mock WS server listening on ws://127.0.0.1:${PERIPHERAL_WS_PORT}`, ) }

[nicomiguelino]

@514sid, this PR is a proof of concept. Please check the TL;DR comment in this PR for reference.

[github-actions]

PR Code Suggestions ✨

Latest suggestions up to ab7323a

Explore these optional code suggestions:

Category	Suggestion	Impact
Possible issue	Fix WebSocket readyState check ws.OPEN is a static constant in ws and is typically not available on the instance, so this condition will almost always short-circuit and prevent periodic snapshots. Compare readyState against the numeric OPEN value instead to ensure pushes actually happen. edge-apps/edge-apps-library/vite-plugins/dev-server.ts [191-201] const interval = setInterval(() => { - if (!identified || ws.readyState !== ws.OPEN) return + // In `ws`, OPEN is `1` (static constant on the class, not reliably on the instance). + if (!identified || ws.readyState !== 1) return const event = JSON.stringify({ request: { id: ulid(), edge_app_source_state: { states: buildStateSnapshot() }, }, }) + ETB ws.send(event) }, 10000) Suggestion importance[1-10]: 8 __ Why: The check ws.readyState !== ws.OPEN is likely always true because OPEN is not reliably present on the ws instance, which would prevent periodic snapshot pushes entirely. Comparing to the actual open state (or a proper constant) fixes a functional bug in the peripheral mock server.	Medium
	Handle ETB message framing WebSocket frames can contain multiple ETB-delimited JSON messages (or partial messages), and replace(ETB, '') only removes the first delimiter. Split by ETB and process each complete chunk to avoid dropping updates or failing JSON parsing when multiple messages arrive together. edge-apps/edge-apps-library/src/peripherals/index.ts [55-94] ws.onmessage = (e: MessageEvent) => { - const text = (e.data as string).replace(ETB, '') - let msg: Record<string, unknown> - try { - msg = JSON.parse(text) as Record<string, unknown> - } catch { - return - } + const raw = String(e.data ?? '') + const chunks = raw.split(ETB).filter(Boolean) - const response = msg.response as Record<string, unknown> | undefined - if ( - response?.ok !== undefined && - (response.ok as Record<string, unknown>)?.identification !== undefined - ) { - identified = true - return - } + for (const text of chunks) { + let msg: Record<string, unknown> + try { + msg = JSON.parse(text) as Record<string, unknown> + } catch { + continue + } - const request = msg.request as Record<string, unknown> | undefined - if (request?.edge_app_source_state) { - const state = request.edge_app_source_state as { - states: Array<{ name: string }> + const response = msg.response as Record<string, unknown> | undefined + if ( + response?.ok !== undefined && + (response.ok as Record<string, unknown>)?.identification !== undefined + ) { + identified = true + continue } - state.states.forEach((s) => { - readings[s.name] = s - }) - notifySubscribers() - send({ - response: { request_id: request.id, ok: 'edge_app_source_state' }, - }) - return - } - if (request?.downstream_node_event) { - send({ - response: { request_id: request.id, ok: 'downstream_node_event' }, - }) - return + const request = msg.request as Record<string, unknown> | undefined + if (request?.edge_app_source_state) { + const state = request.edge_app_source_state as { + states: Array<{ name: string }> + } + state.states.forEach((s) => { + readings[s.name] = s + }) + notifySubscribers() + send({ + response: { request_id: request.id, ok: 'edge_app_source_state' }, + }) + continue + } + + if (request?.downstream_node_event) { + send({ + response: { request_id: request.id, ok: 'downstream_node_event' }, + }) + continue + } } } Suggestion importance[1-10]: 5 __ Why: Splitting on ETB is a reasonable robustness improvement over replace(ETB, ''), which can break if multiple ETB-delimited JSON payloads arrive in a single message event. It’s not clearly required given WebSocket message boundaries, but it can prevent dropped updates if the integrator batches messages.	Low

---

Previous suggestions

Suggestions up to commit 157b403

Category	Suggestion	Impact
Possible issue	Fix readyState OPEN comparison In ws, the readyState constants are not reliably available on the instance (ws.OPEN may be undefined), which can prevent periodic updates from ever sending. Compare readyState to the numeric OPEN value instead to make the mock server consistently push snapshots. edge-apps/edge-apps-library/vite-plugins/dev-server.ts [191-201] const interval = setInterval(() => { - if (!identified || ws.readyState !== ws.OPEN) return + if (!identified || ws.readyState !== 1) return const event = JSON.stringify({ request: { id: ulid(), edge_app_source_state: { states: buildStateSnapshot() }, }, }) + ETB ws.send(event) }, 5000) Suggestion importance[1-10]: 8 __ Why: In ws, OPEN is a static constant (typically WebSocket.OPEN), and ws.OPEN on the instance can be undefined, causing the interval push to never send. Comparing to the correct open state fixes a real functional bug in the mock peripheral snapshot broadcaster.	Medium
	Close mock server and fix logs The server logs "listening" unconditionally even when EADDRINUSE occurs, and it isn't closed when Vite shuts down, which can leave the port occupied across restarts. Return the WebSocketServer from startPeripheralMockServer(), log only on the listening event, and close it on Vite's HTTP server close to avoid port leaks. edge-apps/edge-apps-library/vite-plugins/dev-server.ts [114-319] -function startPeripheralMockServer(): void { +function startPeripheralMockServer(): WebSocketServer { const wss = new WebSocketServer({ port: PERIPHERAL_WS_PORT }) -... + + wss.on('listening', () => { + console.log( + `[screenly-dev-server] Peripheral mock WS server listening on ws://127.0.0.1:${PERIPHERAL_WS_PORT}`, + ) + }) + wss.on('error', (err: NodeJS.ErrnoException) => { if (err.code === 'EADDRINUSE') { console.warn( `[screenly-dev-server] Port ${PERIPHERAL_WS_PORT} already in use — peripheral mock not started.`, ) } else { console.error('[screenly-dev-server] Peripheral WS error:', err.message) } }) - console.log( - `[screenly-dev-server] Peripheral mock WS server listening on ws://127.0.0.1:${PERIPHERAL_WS_PORT}`, - ) + // eslint-disable-next-line max-lines-per-function + wss.on('connection', (ws) => { + let identified = false + ... + }) + + return wss } -... -configureServer(server: ViteDevServer) { - rootDir = server.config.root - // Start peripheral mock WebSocket server - startPeripheralMockServer() +export function screenlyDevServer(): Plugin { + let config: BaseScreenlyMockData + let rootDir: string + let peripheralWss: WebSocketServer | null = null + return { + name: 'screenly-dev-server', + configureServer(server: ViteDevServer) { + rootDir = server.config.root + + // Start peripheral mock WebSocket server + if (!peripheralWss) { + peripheralWss = startPeripheralMockServer() + server.httpServer?.once('close', () => peripheralWss?.close()) + } + + // Generate initial mock data + config = generateMockData(rootDir) + ... + }, + } +} + Suggestion importance[1-10]: 7 __ Why: Logging “listening” unconditionally is misleading when EADDRINUSE happens, and not closing the WebSocketServer can leave the port stuck across dev-server restarts. Returning the server instance, logging on listening, and closing on Vite shutdown materially improves dev reliability.	Medium
	Properly frame WebSocket messages WebSocket messages can arrive split or concatenated, so stripping a single ETB and parsing once can silently drop valid frames or fail on partial JSON. Buffer incoming data and split on ETB, then parse each complete frame. Also guard against non-string MessageEvent.data to avoid parsing "[object Blob]". edge-apps/edge-apps-library/src/peripherals/index.ts [55-94] +let recvBuffer = '' + ws.onmessage = (e: MessageEvent) => { - const text = (e.data as string).replace(ETB, '') - let msg: Record<string, unknown> - try { - msg = JSON.parse(text) as Record<string, unknown> - } catch { - return - } + if (typeof e.data !== 'string') return - const response = msg.response as Record<string, unknown> | undefined - if ( - response?.ok !== undefined && - (response.ok as Record<string, unknown>)?.identification !== undefined - ) { - identified = true - return - } + recvBuffer += e.data + const frames = recvBuffer.split(ETB) + recvBuffer = frames.pop() ?? '' - const request = msg.request as Record<string, unknown> | undefined - if (request?.edge_app_source_state) { - const state = request.edge_app_source_state as { - states: Array<{ name: string }> + for (const frame of frames) { + if (!frame) continue + + let msg: Record<string, unknown> + try { + msg = JSON.parse(frame) as Record<string, unknown> + } catch { + continue } - state.states.forEach((s) => { - readings[s.name] = s - }) - notifySubscribers() - send({ - response: { request_id: request.id, ok: 'edge_app_source_state' }, - }) - return - } - if (request?.downstream_node_event) { - send({ - response: { request_id: request.id, ok: 'downstream_node_event' }, - }) - return + const response = msg.response as Record<string, unknown> | undefined + if ( + response?.ok !== undefined && + (response.ok as Record<string, unknown>)?.identification !== undefined + ) { + identified = true + continue + } + + const request = msg.request as Record<string, unknown> | undefined + if (request?.edge_app_source_state) { + const state = request.edge_app_source_state as { + states: Array<{ name: string }> + } + state.states.forEach((s) => { + readings[s.name] = s + }) + notifySubscribers() + send({ + response: { request_id: request.id, ok: 'edge_app_source_state' }, + }) + continue + } + + if (request?.downstream_node_event) { + send({ + response: { request_id: request.id, ok: 'downstream_node_event' }, + }) + } } } Suggestion importance[1-10]: 6 __ Why: The current ws.onmessage assumes exactly one JSON payload per WebSocket message and strips only a single ETB, which can break if multiple frames are ever delivered together (or if e.data is not a string). The buffering/splitting approach is a reasonable robustness improvement, though WebSocket message boundaries often already preserve frames.	Low

Suggestions up to commit 2b6f1a8

Category	Suggestion	Impact
Security	Bind to localhost and log correctly Bind the mock WebSocket server explicitly to 127.0.0.1 (the current code likely binds to all interfaces), and only log “listening” after the server is actually listening. This avoids accidental LAN exposure and misleading logs when EADDRINUSE happens. edge-apps/edge-apps-library/vite-plugins/dev-server.ts [76-169] function startPeripheralMockServer(): void { - const wss = new WebSocketServer({ port: PERIPHERAL_WS_PORT }) + const wss = new WebSocketServer({ port: PERIPHERAL_WS_PORT, host: '127.0.0.1' }) + + wss.once('listening', () => { + console.log( + `[screenly-dev-server] Peripheral mock WS server listening on ws://127.0.0.1:${PERIPHERAL_WS_PORT}`, + ) + }) wss.on('connection', (ws) => { let identified = false ... }) - wss.on('error', (err: NodeJS.ErrnoException) => { + wss.once('error', (err: NodeJS.ErrnoException) => { if (err.code === 'EADDRINUSE') { console.warn( `[screenly-dev-server] Port ${PERIPHERAL_WS_PORT} already in use — peripheral mock not started.`, ) } else { console.error('[screenly-dev-server] Peripheral WS error:', err.message) } + try { + wss.close() + } catch { + // ignore + } }) - - console.log( - `[screenly-dev-server] Peripheral mock WS server listening on ws://127.0.0.1:${PERIPHERAL_WS_PORT}`, - ) } Suggestion importance[1-10]: 8 __ Why: The mock WebSocketServer currently binds implicitly (potentially all interfaces) and logs “listening” unconditionally, which can be both a security footgun and misleading when EADDRINUSE occurs. Binding to 127.0.0.1 and logging on the actual listening event improves correctness and reduces accidental exposure.	Medium
Possible issue	Parse ETB-delimited WS frames The WebSocket payload may contain multiple ETB-delimited frames (or a non-Buffer type), and replace(ETB, '') only removes the first ETB, which can break JSON parsing. Split on ETB, parse each frame, and validate requestId before responding to avoid emitting malformed ACKs. edge-apps/edge-apps-library/vite-plugins/dev-server.ts [82-129] -ws.on('message', (raw: Buffer) => { - const text = raw.toString().replace(ETB, '') - let msg: Record<string, unknown> - try { - msg = JSON.parse(text) - } catch { - return +ws.on('message', (raw) => { + const rawText = typeof raw === 'string' ? raw : Buffer.from(raw as any).toString() + const frames = rawText.split(ETB).map((s) => s.trim()).filter(Boolean) + + for (const frame of frames) { + let msg: Record<string, unknown> + try { + msg = JSON.parse(frame) + } catch { + continue + } + + const req = msg.request as Record<string, unknown> | undefined + if (!req) continue + + const requestId = req.id + if (typeof requestId !== 'string' || requestId.length === 0) continue + + // Identification handshake + if (req.identification) { + identified = true + ws.send( + JSON.stringify({ + response: { request_id: requestId, ok: { identification: null } }, + }) + ETB, + ) + continue + } + + if (!identified) continue + + // GetState request + const channelName = req.source_channel_get_state as string | undefined + if (channelName && channelName in SENSOR_META) { + const sensor = channelName as SensorType + const meta = SENSOR_META[sensor] + const value = makeMockSensorValue(sensor) + ws.send( + JSON.stringify({ + response: { + request_id: requestId, + ok: { + source_channel_get_state: { + name: channelName, + [meta.wireKey]: value, + unit: meta.unit, + timestamp: new Date().toISOString(), + }, + }, + }, + }) + ETB, + ) + } } - - const req = msg.request as Record<string, unknown> | undefined - if (!req) return - - const requestId = req.id as string - - // Identification handshake - if (req.identification) { - identified = true - const ack = JSON.stringify({ - response: { request_id: requestId, ok: { identification: null } }, - }) + ETB - ws.send(ack) - return - } - ... }) Suggestion importance[1-10]: 6 __ Why: Using replace(ETB, '') only removes one delimiter and assumes one JSON payload per WS message; splitting by ETB and iterating frames makes the mock more robust to concatenated frames and avoids JSON parse failures. The added requestId validation also prevents emitting malformed ACKs if the payload is unexpected.	Low
	Safely decode and split messages In browsers, e.data can be a Blob/ArrayBuffer, and calling .replace() will throw; additionally, multiple ETB-delimited frames can arrive in a single message. Convert e.data to text safely, split by ETB, and process each frame to prevent runtime crashes and dropped events. edge-apps/edge-apps-library/vite-plugins/dev-server.ts [227-253] -ws.onmessage = (e) => { - const text = e.data.replace(ETB, '') - let msg - try { msg = JSON.parse(text) } catch { return } +ws.onmessage = async (e) => { + const rawText = + typeof e.data === 'string' + ? e.data + : e.data instanceof Blob + ? await e.data.text() + : new TextDecoder().decode(e.data) - // Handle identification ACK - if (msg.response?.ok?.identification !== undefined) { - identified = true - return - } + const frames = rawText.split(ETB).map((s) => s.trim()).filter(Boolean) + for (const frame of frames) { + let msg + try { + msg = JSON.parse(frame) + } catch { + continue + } - // Handle ACK requirement for unsolicited push events - if (msg.request?.source_channel_event) { - const event = normalizeEvent(msg.request.source_channel_event) - if (event) { - subscribers.forEach(cb => cb(event)) - dispatchEvent(new CustomEvent('screenly:peripheral', { detail: event })) + // Handle identification ACK + if (msg.response?.ok?.identification !== undefined) { + identified = true + continue } - send({ response: { request_id: msg.request.id, ok: 'source_channel_event' } }) - return - } - if (msg.request?.downstream_node_event) { - send({ response: { request_id: msg.request.id, ok: 'downstream_node_event' } }) - return + // Handle ACK requirement for unsolicited push events + if (msg.request?.source_channel_event) { + const event = normalizeEvent(msg.request.source_channel_event) + if (event) { + subscribers.forEach((cb) => cb(event)) + dispatchEvent(new CustomEvent('screenly:peripheral', { detail: event })) + } + send({ response: { request_id: msg.request.id, ok: 'source_channel_event' } }) + continue + } + + if (msg.request?.downstream_node_event) { + send({ response: { request_id: msg.request.id, ok: 'downstream_node_event' } }) + continue + } } } Suggestion importance[1-10]: 5 __ Why: In the generated browser-side screenly.js, calling .replace() on e.data assumes a string and can crash if e.data is a Blob/ArrayBuffer; safely decoding and splitting by ETB prevents runtime failures and missed events. This is a defensive improvement (the current mock likely sends text frames), so impact is moderate.	Low

[nicomiguelino]

Don't forget to remove edge-apps/peripheral-integration-poc/ afterwards. We don't need it anymore.