Component Reference

Overview

Components define the capabilities and attributes of entities. This page documents all available components, their fields, and usage patterns.

Core Metadata Components

Controller

Identifies which system contributed this entity to the common operating picture.

Fields:

• id (string) - Unique identifier of the controlling system
• node (string) - Node where the controller runs

Example:

controller: {
  id: 'sensor-array-alpha',
  node: 'edge-node-1'
}

When to use: Attach to entities created by your system to track ownership and data provenance.

Lifetime

Defines the temporal validity of an entity. Hydris automatically expires entities when until is reached.

Fields:

• from (Timestamp, optional) - When this entity becomes valid. Set to now automatically if omitted
• until (Timestamp, optional) - When this entity expires
• fresh (Timestamp, optional) - Last time this entity was seen. Updates with an older fresh value are ignored by default

Example:

lifetime: {
  from: new Date('2025-01-15T10:00:00Z'),
  until: new Date('2025-01-15T18:00:00Z'),
  fresh: new Date('2025-01-15T12:00:00Z')
}

When to use:

• Temporary markers or waypoints
• Time-limited detections
• Scheduled events or planned movements
• Historical data with known validity windows

Priority

Controls Quality of Service for bandwidth-constrained networks (DDIL scenarios).

Values:

• PriorityRoutine (1) - Normal day-to-day traffic. May be delayed or coalesced when bandwidth is constrained
• PriorityImmediate (2) - Delay would negatively affect the mission. Sent before lower precedence messages
• PriorityFlash (3) - Extreme urgency. Sent without respecting bandwidth limits. Misuse can jeopardize missions

Example:

priority: Priority.PriorityImmediate

When to use:

• Set PriorityFlash for immediate threats or emergency alerts
• Use PriorityImmediate for detections and tracks
• Use PriorityRoutine for auxiliary information, metadata, or non-urgent updates

Lease

Used by controllers to negotiate exclusivity on an entity. The engine rejects pushes that attempt to change the holder of an active lease.

Fields:

• controller (string) - Controller ID holding the lease
• expires (Timestamp, optional) - When the lease expires

Example:

lease: {
  controller: 'tracker-1',
  expires: new Date('2025-01-15T10:05:00Z')
}

When to use: Lock an entity so only one controller can modify it at a time. Note that leases are local and not distributed vertically.

Spatial Components

GeoSpatialComponent

Physical location in 3D space using WGS84 coordinates.

Fields:

• longitude (double) - Decimal degrees, -180 to 180
• latitude (double) - Decimal degrees, -90 to 90
• altitude (double, optional) - Meters above WGS84 ellipsoid
• covariance (CovarianceMatrix, optional) - Position uncertainty in ENU frame

Example:

geo: {
  longitude: 13.4050,
  latitude: 52.5200,
  altitude: 100,
  covariance: {
    mxx: 25.0,   // East variance (m²)
    myy: 25.0,   // North variance (m²)
    mzz: 100.0   // Up variance (m²)
  }
}

When to use: Nearly all entities that have a physical location. This is the most common component.

BearingComponent

Absolute bearing in the world, relative to the local ENU frame. For root entities this is set directly; for child entities with a PolarOffset the engine computes it by composing down the pose tree.

Fields:

• azimuth (double, optional) - Clockwise angle from true north in degrees [0, 360)
• elevation (double, optional) - Angle above the local horizontal plane in degrees [-90, 90]

Example:

bearing: {
  azimuth: 270,    // Pointing West
  elevation: 15    // 15 degrees above horizon
}

When to use:

• Camera or sensor pointing direction
• Movement direction for tracks
• Line-of-sight vectors
• Beam directions for RF sensors

OrientationComponent

Absolute orientation in the world, relative to the local ENU frame. For root entities this is set directly; for child entities the engine computes it by composing orientations down the pose tree.

Fields:

• orientation (Quaternion) - Orientation as a unit quaternion (x, y, z, w)
• covariance (CovarianceMatrix, optional) - Orientation uncertainty

Example:

orientation: {
  orientation: { x: 0, y: 0, z: 0.383, w: 0.924 },
}

When to use: Aircraft, drones, or vehicles where full 3D attitude matters beyond simple bearing.

PoseComponent

Defines this entity's position relative to a parent entity's coordinate frame, forming a transform tree. The engine computes absolute GeoSpatialComponent by walking the tree. If the pose cannot be fully resolved (e.g. missing range on a bearing-only sensor), no geo is produced.

Fields:

• parent (string) - Parent entity ID in the transform tree
• cartesian (CartesianOffset) - Offset in meters (east, north, up)
• polar (PolarOffset) - Offset in azimuth/elevation/range

Only one of cartesian or polar can be set.

CartesianOffset fields:

• east_m (double) - East offset in meters
• north_m (double) - North offset in meters
• up_m (double, optional) - Up offset in meters
• covariance (CovarianceMatrix, optional) - Offset uncertainty
• orientation (Quaternion, optional) - Local orientation

PolarOffset fields:

• azimuth (double) - Angle from the parent's forward axis in degrees [0, 360)
• elevation (double, optional) - Above the parent's horizontal plane in degrees [-90, 90]
• range (double, optional) - Distance in meters. Omit for bearing-only (passive sensor)
• covariance (CovarianceMatrix, optional) - Offset uncertainty
• orientation (Quaternion, optional) - Local orientation

Example:

pose: {
  parent: 'radar-1',
  polar: {
    azimuth: 45.0,
    elevation: 10.0,
    range: 5000
  }
}

When to use: Sensor detections relative to a sensor, camera gimbal joints, or any entity whose position is naturally defined relative to another entity.

TargetPoseComponent

Desired pose for a joint, same shape as PoseComponent's offset. A device-specific reconciler continuously drives the actual PoseComponent toward this target.

Fields:

• cartesian (CartesianOffset) - Target offset in meters
• polar (PolarOffset) - Target offset in azimuth/elevation/range

Only one of cartesian or polar can be set.

Example:

target_pose: {
  polar: {
    azimuth: 180.0,
    elevation: -5.0,
    range: 1000
  }
}

When to use: Commanding a PTZ camera gimbal, robotic arm, or any actuated joint to move to a target position.

Visual Representation

SymbolComponent

Visual representation using military symbology standards.

Fields:

• milStd2525C (string) - MIL-STD-2525C symbol identification code (SIDC)

Common SIDCs:

Example:

symbol: {
  milStd2525C: 'SFGPES----'
}

When to use: Any entity that should appear on a tactical display or map.

InteractivityComponent

UI interaction hints for an entity, such as a custom icon or a reference URL where a user can learn more.

Fields:

• icon (string, optional) - Icon name (use Lucide icon names for max compatibility)
• reference_url (string, optional) - URL where a user can learn more about this entity

Example:

interactivity: {
  icon: 'radio',
  reference_url: 'https://example.com/asset/123'
}

When to use: Entities that benefit from a custom icon in the UI or link to an external detail page.

Sensor and Detection Components

DetectionComponent

Links a detection to its source sensor and provides classification.

Fields:

• detectorEntityId (string, optional) - ID of the sensor entity that made this detection
• classification (string, optional) - Type classification (e.g., "drone", "vehicle", "person")
• lastMeasured (Timestamp, optional) - When this detection was last updated

Example:

detection: {
  detectorEntityId: 'radar-1',
  classification: 'drone',
  lastMeasured: new Date('2025-01-15T10:30:00Z')
}

When to use: Raw sensor detections before track fusion.

TrackComponent

Marks an entity as a fused track and optionally links to track history, prediction geometries, and contributing detections.

Fields:

• tracker (string, optional) - ID of the tracker/fusion engine that owns this track
• history (string, optional) - Entity ID of a GeoShapeComponent containing the track history
• prediction (string, optional) - Entity ID of a GeoShapeComponent containing the predicted forward track
• detections (string[], optional) - Detection entity IDs that contribute to this track

Example:

track: {
  tracker: 'fusion-engine-1',
  history: 'track-42.history',
  prediction: 'track-42.orbit',
  detections: ['det-1', 'det-2', 'det-3']
}

When to use: After correlating multiple detections from different sensors into a unified track. Link to history/prediction shape entities for trail and forecast visualization.

SensorComponent

Describes a sensor's coverage area by linking to GeoShapeComponent entities.

Fields:

• coverage (string[]) - Entity IDs of GeoShapeComponent entities that describe the sensor's coverage area

Example:

sensor: {
  coverage: ['radar-1.coverage-left', 'radar-1.coverage-right']
}

When to use: Radars, cameras, or any sensor where you want to visualize the coverage footprint on the map.

LocatorComponent

Indicates this sensor is actively locating another entity.

Fields:

• locatedEntityId (string) - ID of the entity being located/tracked

Example:

locator: {
  locatedEntityId: 'target-001'
}

When to use: Show which sensors are tracking which targets, sensor-to-target associations.

TransponderComponent

Transponder identifiers for AIS (maritime) and ADS-B (aviation) targets.

Fields:

• ais (TransponderAIS, optional) - AIS transponder data
• adsb (TransponderADSB, optional) - ADS-B transponder data

TransponderAIS fields:

• mmsi (uint32, optional) - Maritime Mobile Service Identity
• imo (uint32, optional) - IMO ship identification number
• callsign (string, optional) - Radio callsign
• vessel_name (string, optional) - Vessel name

TransponderADSB fields:

• icao_address (uint32, optional) - ICAO 24-bit aircraft address
• flight_id (string, optional) - Flight identification / callsign

Example:

transponder: {
  ais: {
    mmsi: 211234567,
    imo: 9876543,
    callsign: 'DABC',
    vessel_name: 'MS EXAMPLE'
  }
}

When to use: Entities originating from AIS or ADS-B sources. Set automatically by the AIS and ADS-B builtins.

AdministrativeComponent

Administrative and registration data for vessels, aircraft, or other registered assets.

Fields:

• id (string, optional) - Registration ID (e.g. tail number, hull number)
• flag (string, optional) - Flag state or ICAO type code
• owner (string, optional) - Registered owner or operator
• manufacturer (string, optional) - Manufacturer name
• model (string, optional) - Model designation
• year_built (uint32, optional) - Year of manufacture
• length_m (float, optional) - Length in meters
• tonnage_gt (float, optional) - Gross tonnage
• engine_power_kw (float, optional) - Engine power in kilowatts

Example:

administrative: {
  id: 'D-AIBL',
  owner: 'Lufthansa',
  manufacturer: 'Airbus',
  model: 'A319-112',
  year_built: 2010
}

When to use: Enrichment data for tracked assets. Set automatically by the adsbdb and hexdb enrichment builtins.

Camera and Observation

CameraComponent

Provides video feed URLs and optical parameters for cameras and observation sensors.

Fields:

• streams (array of MediaStream) - List of available media streams
• focal_point (string, optional) - If the camera is PTZ, the entity ID representing where this camera is looking. The device driver reconciles target_pose with physical actuation of the gimbal
• fov (double, optional) - Horizontal field of view in degrees, centered on the entity's azimuth. For varifocal cameras, this is the current effective FOV
• range_min (double, optional) - Minimum detection range in meters (blind zone)
• range_max (double, optional) - Maximum detection range in meters
• fov_wide (double, optional) - Horizontal FOV at widest zoom in degrees (varifocal cameras)
• fov_tele (double, optional) - Horizontal FOV at max zoom in degrees (varifocal cameras)

MediaStream fields:

• label (string) - Display name for this stream
• url (string) - Streaming URL
• protocol (MediaStreamProtocol) - Streaming protocol type
• role (MediaStreamRole) - Stream role
• codec (string) - Video codec (e.g. "H264", "H265")
• width (int32, optional) - Resolution width in pixels
• height (int32, optional) - Resolution height in pixels

MediaStreamProtocol values:

• MediaStreamProtocolWebrtc - WebRTC stream
• MediaStreamProtocolHls - HLS stream
• MediaStreamProtocolMjpeg - MJPEG stream
• MediaStreamProtocolImage - Static image URL
• MediaStreamProtocolIframe - Embedded iframe
• MediaStreamProtocolRtsp - RTSP stream

MediaStreamRole values:

• MediaStreamRoleMain - Primary high-resolution stream
• MediaStreamRoleSub - Lower-resolution sub stream
• MediaStreamRoleSnapshot - Still image capture

Example:

camera: {
  streams: [
    {
      label: 'Main View',
      url: 'https://camera.example.com/stream1',
      protocol: MediaStreamProtocol.MediaStreamProtocolHls,
      role: MediaStreamRole.MediaStreamRoleMain,
      codec: 'H264',
      width: 1920,
      height: 1080
    },
    {
      label: 'Thermal',
      url: 'https://camera.example.com/thermal',
      protocol: MediaStreamProtocol.MediaStreamProtocolMjpeg,
      role: MediaStreamRole.MediaStreamRoleSub
    }
  ],
  focal_point: 'camera-1.target',
  fov: 60.0,
  range_min: 5,
  range_max: 10000,
  fov_wide: 90.0,
  fov_tele: 3.5
}

When to use: PTZ cameras, UAV feeds, fixed surveillance cameras.

CaptureComponent

Raw payload capture from a device, for example LoRaWAN uplinks or UDP packets.

Fields:

• payload (bytes, optional) - Last raw payload received
• port (uint32, optional) - Application-level port (e.g. LoRaWAN FPort, UDP port)
• content_type (string, optional) - Content type hint (e.g. "application/octet-stream", "application/json")
• captured_by (string, optional) - Entity ID of the device that captured this data
• captured_at (Timestamp, optional) - When the payload was captured

Example:

capture: {
  payload: new Uint8Array([0x01, 0x02, 0x03]),
  port: 1,
  content_type: 'application/octet-stream',
  captured_by: 'lorawan-gw-1',
  captured_at: new Date('2025-01-15T10:30:00Z')
}

When to use: IoT/LPWAN devices, raw data ingestion pipelines, protocol decoding.

Task and Assignment

TaskableComponent

Defines an assignable task with context, assignees, and a parameter schema.

Fields:

• label (string, optional) - Human-readable task description
• context (array of TaskableContext) - Entities this task relates to
• assignee (array of TaskableAssignee) - Entities assigned to execute this task
• schema (Struct) - JSON schema describing the task parameters
• mode (TaskableMode) - Execution mode

TaskableContext/TaskableAssignee fields:

• entityId (string, optional) - ID of referenced entity

TaskableMode values:

Example:

taskable: {
  label: 'View with Camera',
  context: [
    { entityId: 'target-001' }
  ],
  assignee: [
    { entityId: 'camera-1' }
  ],
  schema: { type: 'object', properties: { zoom: { type: 'number' } } },
  mode: TaskableMode.TaskableModeExclusive
}

When to use:

• Assign sensors to track targets
• Create inspection tasks
• Coordinate multiple assets on a mission
• Workflow automation between systems

TaskExecutionComponent

An instance of a task being executed. Created by RunTask, referencing a TaskableComponent entity as the definition. The controller that owns the taskable watches for these and executes them.

Fields:

• task (string) - Entity ID of the TaskableComponent that defines this task
• parameters (Struct, optional) - Parameters supplied by the caller, validated against the taskable's schema
• state (TaskExecutionState) - Current execution state
• reason (string, optional) - Human-readable error or result message
• priority (uint32, optional) - Priority level for PriorityQueue mode (higher = more important)

TaskExecutionState values:

Example:

task_execution: {
  task: 'taskable-view-camera',
  parameters: { zoom: 10 },
  state: TaskExecutionState.TaskExecutionStateRunning
}

When to use: Automatically created by RunTask. Controllers watch for these on their taskable entities and execute accordingly.

Kinematics

KinematicsComponent

Velocity, acceleration, and angular velocity. Linear components use the local East-North-Up (ENU) coordinate frame.

Fields:

• velocityEnu (KinematicsEnu, optional) - Velocity vector in m/s
• accelerationEnu (KinematicsEnu, optional) - Acceleration vector in m/s²
• angularVelocityBody (AngularVelocity, optional) - Angular velocity around the entity's body axes

KinematicsEnu fields:

• east (double, optional) - East component in m/s (or m/s² for acceleration)
• north (double, optional) - North component
• up (double, optional) - Up component
• covariance (CovarianceMatrix, optional) - Velocity/acceleration uncertainty

AngularVelocity fields:

• roll_rate (double) - Roll rate in radians/second
• pitch_rate (double) - Pitch rate in radians/second
• yaw_rate (double) - Yaw rate in radians/second

The ENU frame is a right-handed Cartesian coordinate system with origin at the entity's position, where:

• East axis: tangent to the latitude line, pointing eastward
• North axis: tangent to the longitude line, pointing northward
• Up axis: perpendicular to the WGS84 ellipsoid, pointing away from Earth center

Note: This is NOT a body frame - the axes do not rotate with the entity's heading/attitude.

Example:

kinematics: {
  velocityEnu: {
    east: 10.5,   // Moving east at 10.5 m/s
    north: -5.2,  // Moving south at 5.2 m/s
    up: 0.0       // No vertical movement
  },
  accelerationEnu: {
    east: 0.1,
    north: 0.0,
    up: 0.0
  },
  angularVelocityBody: {
    roll_rate: 0.0,
    pitch_rate: 0.0,
    yaw_rate: 0.1   // Turning right
  }
}

When to use: Moving tracks, aircraft, vehicles, or any entity with known velocity/acceleration.

Geometry

GeoShapeComponent

Defines geographic shapes beyond simple point locations.

Fields:

• geometry (Geometry, optional) - The shape definition

Geometry types:

• planar.point - A single 2.5D point (longitude, latitude, optional altitude)
• planar.line - A path/line defined by multiple points (ring)
• planar.polygon - An enclosed area with optional holes
• planar.circle - A circle defined by center point and radius

PlanarPoint fields:

• longitude (double) - Decimal degrees, -180 to 180
• latitude (double) - Decimal degrees, -90 to 90
• altitude (double, optional) - Meters above WGS84 ellipsoid

PlanarPolygon fields:

• outer (PlanarRing) - The outer boundary (must be closed: first point = last point)
• holes (array of PlanarRing, optional) - Interior holes

PlanarCircle fields:

• center (PlanarPoint) - Center point
• radius_m (double) - Radius in meters
• inner_radius_m (double, optional) - Inner radius in meters (omit for solid circle)

Example:

shape: {
  geometry: {
    planar: {
      polygon: {
        outer: {
          points: [
            { longitude: 13.4, latitude: 52.5 },
            { longitude: 13.5, latitude: 52.5 },
            { longitude: 13.5, latitude: 52.6 },
            { longitude: 13.4, latitude: 52.6 },
            { longitude: 13.4, latitude: 52.5 }  // Closed ring
          ]
        }
      }
    }
  }
}

When to use: Zones, boundaries, flight corridors, no-fly areas, search areas.

LocalShapeComponent

Geometry defined in a local ENU frame relative to another entity, using meter offsets instead of geographic coordinates.

Fields:

• relative_to (string) - Entity ID whose frame this geometry is defined in
• geometry (LocalGeometry, optional) - The local shape definition

LocalGeometry types:

• point - A single point (east_m, north_m, optional up_m)
• line - A path defined by multiple local points
• polygon - An enclosed area in local coordinates
• circle - A circle with center in local coordinates and radius in meters

Example:

local_shape: {
  relative_to: 'radar-1',
  geometry: {
    circle: {
      center: { east_m: 0, north_m: 0, up_m: 0 },
      radius_m: 5000
    }
  }
}

When to use: Sensor coverage areas, exclusion zones around assets, or any geometry naturally defined relative to an entity rather than in absolute coordinates.

Classification

ClassificationComponent

Structured classification using standard military identity and battle dimension.

Fields:

• dimension (ClassificationBattleDimension, optional) - The battle dimension
• identity (ClassificationIdentity, optional) - Friend/foe identification

ClassificationIdentity values:

ClassificationBattleDimension values:

Example:

classification: {
  dimension: ClassificationBattleDimension.ClassificationBattleDimensionAir,
  identity: ClassificationIdentity.ClassificationIdentityHostile
}

When to use: Tracks and detections where structured IFF data is available, separate from or in addition to MIL-STD-2525C symbology.

Navigation and Mission

NavigationComponent

Live navigation telemetry of an asset - its current mode, arming state, and mission progress.

Fields:

• mode (NavigationMode, optional) - Current navigation mode
• armed (bool, optional) - Whether the asset is armed / active
• emergency (bool, optional) - Emergency flag (squawk 7700, etc.)
• waypoint_current (uint32, optional) - Current waypoint index in the active mission
• waypoint_total (uint32, optional) - Total number of waypoints

NavigationMode values:

Example:

navigation: {
  mode: NavigationMode.NavigationModeAutonomous,
  armed: true,
  waypoint_current: 3,
  waypoint_total: 12
}

When to use: Drones, autonomous vehicles, vessels, or any asset reporting navigation telemetry.

MissionComponent

Groups assets into a mission with a description, destination, and ETA.

Fields:

• members (string[], optional) - Entity IDs of assets participating in this mission
• description (string, optional) - Human-readable status (can be multi-line / markdown)
• destination (string, optional) - Human-readable destination (e.g. port name)
• eta (Timestamp, optional) - Estimated time of arrival

Example:

mission: {
  members: ['vessel-1', 'vessel-2'],
  description: 'Transit to port',
  destination: 'Hamburg',
  eta: new Date('2026-03-15T14:00:00Z')
}

When to use: Vessel voyages with destination/ETA, drone missions, convoy tracking, or any coordinated multi-asset operation.

Link and Power

LinkComponent

Communication link quality and status for an entity, typically set by radio or mesh integrations.

Fields:

• status (LinkStatus, optional) - Link health
• rssi_dbm (sint32, optional) - Received signal strength in dBm
• snr_db (sint32, optional) - Signal-to-noise ratio in dB
• via (string, optional) - Entity ID of the device managing the link
• last_latency_ms (uint32, optional) - Last measured end-to-end latency in milliseconds
• avg_latency_ms (uint32, optional) - Exponential moving average of latency in milliseconds
• last_seen (Timestamp, optional) - Last time data was received over this link

LinkStatus values:

Example:

link: {
  status: LinkStatus.LinkStatusConnected,
  rssi_dbm: -85,
  snr_db: 12,
  via: 'meshtastic.radio-1',
  last_latency_ms: 250,
  avg_latency_ms: 180
}

When to use: Set automatically by the Meshtastic builtin for mesh-received entities. Can also be set manually to indicate link quality for any networked asset.

PowerComponent

Battery and power status for an entity.

Fields:

• battery_charge_remaining (float, optional) - Charge level from 0.0 to 1.0
• voltage (float, optional) - Battery or board voltage in volts
• remaining_seconds (uint32, optional) - Estimated remaining operating time in seconds

Example:

power: {
  battery_charge_remaining: 0.73,
  voltage: 3.85,
  remaining_seconds: 7200
}

When to use: Battery-powered assets like drones, mesh radios, or remote sensors. Set automatically by the Meshtastic builtin from device telemetry.

Device and Configuration

DeviceComponent

Represents a physical or logical device in the device tree. Describes hardware topology only - can be discovered automatically or created by hand.

Fields:

• parent (string, optional) - Parent device entity ID, forming the device tree. Unset for root (node)
• composition (string[], optional) - Non-direct ancestor entity IDs
• unique_hardware_id (string, optional) - Stable hardware identifier (e.g. USB serial number, MAC address)
• state (DeviceState) - DeviceStatePending, DeviceStateActive, or DeviceStateFailed
• error (string, optional) - Error message if state is failed
• class (string, optional) - Device class (e.g. "usb_serial", "radio", "camera")
• category (string, optional) - Human-readable category for UI grouping (e.g. "Air", "Sea", "Network")
• node (NodeDevice, optional) - Node descriptor (hostname, OS, arch, CPU count)
• usb (UsbDevice, optional) - USB descriptor (VID, PID, manufacturer, product, serial)
• ip (IpDevice, optional) - IP descriptor (host, port)
• serial (SerialDevice, optional) - Serial descriptor (path, baud rate)
• ethernet (EthernetDevice, optional) - Ethernet descriptor (MAC address, vendor)
• lpwan (LPWANDevice, optional) - LPWAN descriptor (EUI, address)

EthernetDevice fields:

• mac_address (string, optional) - MAC address in canonical colon-separated hex (e.g. "aa:bb:cc:dd:ee:ff")
• vendor (string, optional) - Vendor name resolved from the OUI prefix

LPWANDevice fields:

• eui (string, optional) - IEEE 802 EUI-64 identifier (e.g. "a84041c6545d1429")
• address (string, optional) - Network address assigned after join/activation (e.g. "012a7125")

When to use: You generally don't create device entities directly. They are published by builtins like serial and meshtastic when hardware is discovered.

ConfigurableComponent

Presence of this component indicates a controller is managing this entity. It declares what can be configured and reports the controller's state. Always on the same entity as a DeviceComponent.

Fields:

• schema (Struct) - JSON schema describing accepted configuration
• value (Struct) - Current state reported by the controller
• state (ConfigurableState) - Current configurable state
• error (string, optional) - Error message if state is failed
• label (string, optional) - Human-readable label for the UI (e.g. "Defaults", "USB Device")
• applied_version (uint64) - Echoed from ConfigurationComponent.version after the controller has finished processing
• supported_device_classes (array of DeviceClassOption) - Device classes that can be attached underneath this entity
• scheduled_at (Timestamp, optional) - When the controller will activate this entity

ConfigurableState values:

When to use: Published by controllers to advertise their configuration schema and report state. Users interact with this indirectly through ConfigurationComponent.

ConfigurationComponent

Configuration pushed onto an entity. The engine delivers entities with this component to the matching controller via Reconcile.

Fields:

• value (Struct) - Configuration values as a JSON object
• version (uint64) - Monotonically increasing counter. The controller echoes this back in ConfigurableComponent.applied_version once processed

Example:

config: {
  value: {
    host: '153.44.253.27',
    port: 5631,
    entity_expiry_seconds: 300
  },
  version: 1
}

When to use: Activating and configuring builtin integrations. See the Builtin Integrations reference for all available config keys.

Component Combinations

Common Patterns

Basic Position Marker:

{ id, geo, symbol }

Sensor Station:

{ id, geo, symbol, bearing, camera, sensor }

Detection:

{ id, geo, detection, bearing }

Fused Track:

{ id, geo, symbol, track, bearing, kinematics, classification }

Maritime Vessel (from AIS):

{ id, geo, symbol, kinematics, transponder, administrative, navigation, mission }

Aircraft (from ADS-B):

{ id, geo, symbol, kinematics, transponder, administrative, classification }

Mesh Radio Node:

{ id, geo, symbol, link, power }

Zone/Area:

{ id, label, shape, symbol }

PTZ Camera with Gimbal:

{ id, geo, symbol, camera, bearing }
// + child entity with pose (relative to camera) and target_pose

Task Assignment:

{ id, taskable }

Builtin Config:

{ id, config }

IoT Device:

{ id, geo, capture, link, power }

Next Steps

• Creating Entities - Learn how to create entities with components
• Understanding Entities - Learn about the Entity Component System