A driver, a media feed and three ready-made blocks for Hive media players, controlled through the Nectar API (apiVersion 1.0). The driver publishes every layer, the play list, the media catalogue and the timecode cue lists, and can act as a Blocks clock follower so a Hive layer or play list runs in step with a Blocks timeline.

Developed and verified against a Hive BeeBlade player on the bench, September–October 2026. Both transports are used at once: the WebSocket carries live state, REST carries commands.

script/driver/Hive.ts
script/feed/HiveMedia.ts
public/block/Hive/TestPanel
public/block/Hive/MediaBrowser
public/block/Hive/MediaPanel

If this document conflicts with the source code, the header comment in script/driver/Hive.ts takes precedence.

Create a TCP Network Device with the following settings:

• Address: Player IP address
• Port: 80

The driver opens the patch WebSocket on port 9002 by itself. Nothing else needs configuring for a player out of the box.

All options are JSON, set on the Network Device page, and all are optional:

{
  "uiDerivedPaths": true,
  "timeReadInterval": 5000,
  "username": "",
  "password": ""
}

The then argument says what to do once the jump has landed: play, pause or stop. Left out, the list keeps doing whatever it was doing. The same argument is on the layer callables that move the play head.

Layers are published as a named aggregate, layers.layer_1, layers.layer_2 and so on. The numbering is Hive's own and cannot be renamed.

media and folder wrap round, so a panel's +/− buttons can run past either end: past a folder's last file comes its first, below 0 comes its last, and a number no file uses moves on to the next file in the direction of travel. Changing folder selects that folder's first file. Media 0 is left alone, since it is black and stops the layer.

blendMode, transitionMode and framingMode are enumerated string properties, so the editor offers a drop-down of the names rather than a number.

cue, cueName, cueStart and cueClock need uiDerivedPaths.

The player's files are published twice over, from one catalogue read:

• mediaList[] an indexed property, folder then number order, for a replicated list.
• media.<key> the same rows keyed ISE_2026_0007 or root_0001: the folder name, or root, then the 4-digit number. A key survives folders coming and going, where a folder number shifts, so a binding made through a key keeps working.

Black has a member of its own, media.root_0000 (0000_BLACK.jpg), which mediaList leaves out. Its onLayerN reads true while that layer is stopped, writing true stops the layer, and writing false plays the layer's selection again so a panel can put a layer to black from the same list it picks media from.

The catalogue is re-read at startup, on refresh(), when refreshMedia() finishes, when Hive's UI rewrites its media list (an upload or a delete, within about a second), and every mediaCheckInterval for changes nothing announces.

Eleven read-only callables that print what the player says into the Blocks log: logNames, logMedia, logPlaylist, logSystemInfo, logStorage, logNetwork, logPlaybackLog, logHiveLog, logNectarLog, logDeviceLog and logSyncStatus (the BeeSync and PTP summary how well a cluster is locked together).

system.logging.lastLog holds what the last of them printed, so a panel or a Task can show it without reading the log.

Generic access for anything the driver does not publish the vendor states the path list is not exhaustive, so this is the escape hatch:

Note: an unknown patch path is not refused. It reads back as 0, "" or null with success: true, so a mistyped path looks like a working one with a boring value.

Hive has no transport verbs. Play, pause and stop are writes to PLAY MODE, and stop is media: 0000_BLACK.jpg, which Hive keeps in every folder. The driver hides that behind status, and remembers the running mode so a layer authored as Play Once Forward is not quietly turned into a loop.

The player is authoritative. State is watched over the WebSocket and applied as it arrives, so a change made in Hive's own UI shows up in Blocks without polling.

Clocks are read, not watched. A watch on a running clock pushes a message every frame measured at 50 messages/s per clock path on the bench player, 201 messages/s and 25.6 kB/s in total with a play list running. The API offers no throttle or deadband, so instead the driver reads a running layer's clock every timeReadInterval (5 s) and the play list's every playlistTimeReadInterval (1 s), with one extra read just after a row should end. A still clock is watched, since it sends nothing until it moves. The trade-off: a pause made in Hive's UI shows within about a second, a seek on a running layer within five.

A still is published still. Hive runs a picture or a .url page as a one-second clip on a loop, so its clock wraps every second. The driver publishes time at 0 with rate 0 for those, as Hive's own progress bar does, while status stays play.

Stopping a play list takes two steps. The driver pauses the list first, waits 400 mS and then turns Use Playlist off, which leaves the target layer clean. A play or pause command sent meanwhile cancels the pending turn-off.

The play list owns its target layer. Transport, media and seek commands to that layer are refused while the list is on, with one warning in the log. Setting media on it is remembered and applied once the list lets go.

Commands go over REST, state comes over the WebSocket. If the stream drops, the driver falls back to polling the watched paths every pollInterval and says so once; connected goes false while either half is missing.

startSync(path) on a layer, or playlistStartSync(path), makes a Blocks TimeFlow property the master. The driver then follows position and, with syncRate, rate. A drift beyond syncDrift is corrected; a change beyond syncJump counts as a seek. A dead master a stopped Blocks timeline is treated per syncStopAction.

Hive has ratecontrol - PLAY SPEED, 0…1, where 0.5 is normal so it can follow a master's rate rather than chase its position.

Turn protection on in Hive's UI and every route each /api call, the thumbnails and the UI itself answers a request without a session with a redirect to the login page. Give the driver username and password in the options and it logs in by itself; the session lasts an hour, and the next request after that logs in again.

Important: the login is sent over the device's own TCP connection, not through the HTTP client, because Hive sets the session cookie on a redirect that the client follows and discards. One consequence: a protected player cannot be logged in to over https, since that raw connection speaks plain HTTP only.

Without a working login connected reads false, even though the stream is up, because every command would be refused. The log says once what to add.

Port 9002 has no authentication of any kind, and password protection does not cover it. Anything that can reach the player there can read and write any patch path, and stop the show. Keep it on a trusted network.

script/feed/HiveMedia.ts publishes, for every network device running this driver:

Each file row carries subPath, the path of its live member in the driver's media aggregate, so a row's lamp and buttons bind through it Network.[Relative.subPath].playing, .onLayer1 and so on.

Thumbnails are copied, not linked. The feed caches each one under /public/hivethumbs/<device>/ with the player's ETag in the file name, and a row's thumbnail is that served path so Spots never need to reach the player. On a protected player the feed borrows the driver's session to fetch them.

The three blocks are ready to use and are described in their own README.md:

• Hive/TestPanel every layer control, the play list and its markers, for the bench.
• Hive/MediaBrowser the media folder by folder, with thumbnails, one page per folder.
• Hive/MediaPanel the whole media list, flat.

Hive's documented path list is explicitly not exhaustive, and some useful state lives on paths found in the player's own web UI rather than in the catalogue. Those are used only while uiDerivedPaths is true, which is the default.

Set it false and the driver uses the documented API alone. What stops working:

• playlistTime and playlistRowTime stay at 0, so nothing can follow the play list's clock;
• cue, cueName, cueStart and cueClock stop reporting;
• the play list's pause goes through Use Playlist alone, so stopping it may leave a video running;
• seeks within a layer use the documented path only.