feat: support generic vendor middleware in data item transforms

Extend `RawDataItem` / `transformDataResponse` to treat the SOVD
`x-medkit` vendor extension as generic metadata rather than a
ROS-2-only construct:

- accept `middleware`, `access`, `type`, `direction`, `encoding` as
  optional vendor fields on the data item
- when the gateway inlines `value`, mark the resulting topic as
  `status: 'data'` instead of always `metadata_only`, so non-streaming
  middlewares render their current value immediately
- use `x-medkit.type` as the type label when no ROS 2 message type is
  available
- recognise `input` / `output` as alternative direction terms alongside
  `publish` / `subscribe` / `both`
- fall back to `x-medkit.direction` when `ros2.direction` is absent

ROS 2 behaviour is unchanged; everything new is additive.

Author: bburda

src/lib/transforms.test.ts

@@ -489,6 +489,76 @@ describe('transformDataResponse', () => {
         const result = transformDataResponse({ items: [] });
         expect(result).toEqual([]);
     });
+
+    describe('generic vendor middleware extensions', () => {
+        it('marks status="data" and passes value through when gateway inlines value', () => {
+            const raw = {
+                id: 'sensor/temperature',
+                name: 'sensor/temperature',
+                value: 42.5,
+                'x-medkit': { middleware: 'generic', access: 'read', type: 'float32' },
+            };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.status).toBe('data');
+            expect(result[0]?.data).toBe(42.5);
+        });
+
+        it('keeps status="metadata_only" when value is absent', () => {
+            const raw = { id: 'x', name: 'x', 'x-medkit': { middleware: 'generic' } };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.status).toBe('metadata_only');
+            expect(result[0]?.data).toBeNull();
+        });
+
+        it('preserves null value with status="data"', () => {
+            const raw = { id: 'x', name: 'x', value: null };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.status).toBe('data');
+            expect(result[0]?.data).toBeNull();
+        });
+
+        it('uses x-medkit.type as type label when ros2.type is absent', () => {
+            const raw = {
+                id: 'payload',
+                name: 'payload',
+                'x-medkit': { middleware: 'generic', type: 'u16' },
+            };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.type).toBe('u16');
+        });
+
+        it('prefers ros2.type over x-medkit.type when both present', () => {
+            const raw = {
+                id: 'x',
+                name: 'x',
+                'x-medkit': { type: 'generic-label', ros2: { type: 'std_msgs/msg/Int32' } },
+            };
+            const result = transformDataResponse({ items: [raw] });
+            // ROS 2 type is preferred so canonical topics stay recognisable.
+            // Keeps precedence consistent with `direction`.
+            expect(result[0]?.type).toBe('std_msgs/msg/Int32');
+        });
+
+        it('treats direction "output" as publish', () => {
+            const raw = { id: 'x', name: 'x', 'x-medkit': { direction: 'output' } };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.isPublisher).toBe(true);
+            expect(result[0]?.isSubscriber).toBe(false);
+        });
+
+        it('treats direction "input" as subscribe', () => {
+            const raw = { id: 'x', name: 'x', 'x-medkit': { direction: 'input' } };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.isPublisher).toBe(false);
+            expect(result[0]?.isSubscriber).toBe(true);
+        });
+
+        it('reads direction from x-medkit.direction when ros2.direction is absent', () => {
+            const raw = { id: 'x', name: 'x', 'x-medkit': { direction: 'publish' } };
+            const result = transformDataResponse({ items: [raw] });
+            expect(result[0]?.uniqueKey).toBe('x:publish');
+        });
+    });
 });
 
 // =============================================================================

src/lib/transforms.ts

@@ -214,6 +214,10 @@ interface RawOperation {
  * Transform the raw operations list response into `Operation[]`.
  *
  * Extracts `kind`, `path`, and `type` from the `x-medkit` vendor extension.
+ *
+ * NOTE: currently only reads `x-medkit.ros2.*`. Extending the generic
+ * middleware fallback here (parity with `transformDataResponse`) is tracked
+ * separately.
  */
 export function transformOperationsResponse(rawData: unknown): Operation[] {
     if (!rawData || typeof rawData !== 'object') return [];
@@ -275,12 +279,27 @@ export function transformOperationsResponse(rawData: unknown): Operation[] {
 
 /**
  * Raw data item shape from the gateway data endpoint.
+ *
+ * Fields under `x-medkit` are generic SOVD vendor extensions. Gateways may
+ * populate any subset depending on the underlying middleware; the UI treats
+ * them as optional metadata and falls back to ROS 2 semantics when they are
+ * absent.
  */
 interface RawDataItem {
     id: string;
     name?: string;
     category?: string;
+    /** Current value inlined by the gateway when available. */
+    value?: unknown;
     'x-medkit'?: {
+        /** Middleware identifier (e.g. 'ros2'); consumers treat any other value as non-ROS 2. */
+        middleware?: string;
+        /** Access mode ('read' | 'write' | 'readwrite'). */
+        access?: string;
+        /** Vendor-provided type label, used when no ROS 2 message type is available. */
+        type?: string;
+        /** Direction: 'publish'/'subscribe'/'both' or 'input'/'output' as alternative terms. */
+        direction?: string;
         ros2?: { topic?: string; type?: string; direction?: string };
         type_info?: { schema?: unknown; default_value?: unknown };
     };
@@ -290,30 +309,40 @@ interface RawDataItem {
  * Transform the raw data list response into `ComponentTopic[]`.
  *
  * Extracts topic metadata (type, direction, schema) from the `x-medkit` extension.
+ * When the gateway inlines a `value`, the resulting topic is marked as `status:
+ * 'data'` so that non-streaming middlewares render their current value immediately.
  */
 export function transformDataResponse(rawData: unknown): ComponentTopic[] {
     if (!rawData || typeof rawData !== 'object') return [];
     const dataItems = unwrapItems<RawDataItem>(rawData);
     return dataItems.map((item) => {
-        const rawTypeInfo = item['x-medkit']?.type_info;
+        const xm = item['x-medkit'];
+        const rawTypeInfo = xm?.type_info;
         const convertedSchema = rawTypeInfo?.schema ? convertJsonSchemaToTopicSchema(rawTypeInfo.schema) : undefined;
-        const direction = item['x-medkit']?.ros2?.direction;
-        const topicName = item.name || item['x-medkit']?.ros2?.topic || item.id;
+        // `input`/`output` are alternative direction terms used by non-ROS 2 middlewares.
+        const direction = xm?.ros2?.direction ?? xm?.direction;
+        const topicName = item.name || xm?.ros2?.topic || item.id;
+        // Prefer the ROS 2 message type when present so canonical topics stay
+        // recognisable; the generic vendor label only fills the gap when no
+        // ROS 2 type was published. This keeps precedence consistent with
+        // `direction` above.
+        const typeLabel = xm?.ros2?.type ?? xm?.type;
+        const hasValue = item.value !== undefined;
         return {
             topic: topicName,
             timestamp: Date.now(),
-            data: null,
-            status: 'metadata_only' as const,
-            type: item['x-medkit']?.ros2?.type,
+            data: hasValue ? item.value : null,
+            status: hasValue ? ('data' as const) : ('metadata_only' as const),
+            type: typeLabel,
             type_info: convertedSchema
                 ? {
                       schema: convertedSchema,
                       default_value: rawTypeInfo?.default_value as Record<string, unknown>,
                   }
                 : undefined,
             // Direction-based fields for apps/functions.
-            isPublisher: direction === 'publish' || direction === 'both',
-            isSubscriber: direction === 'subscribe' || direction === 'both',
+            isPublisher: direction === 'publish' || direction === 'both' || direction === 'output',
+            isSubscriber: direction === 'subscribe' || direction === 'both' || direction === 'input',
             uniqueKey: direction ? `${topicName}:${direction}` : topicName,
         };
     });
@@ -339,6 +368,10 @@ interface RawConfigurationsResponse {
  *
  * All meaningful data lives in the `x-medkit` extension. The `entityId` parameter
  * is used as a fallback when `x-medkit` fields are absent.
+ *
+ * NOTE: currently only reads `x-medkit.ros2.*`. Extending the generic
+ * middleware fallback here (parity with `transformDataResponse`) is tracked
+ * separately.
  */
 export function transformConfigurationsResponse(rawData: unknown, entityId: string): ComponentConfigurations {
     if (!rawData || typeof rawData !== 'object') {