@totemsdk/act-mavlink 0.0.0-stage → 0.1.0

package/dist/envelope.d.ts

@@ -0,0 +1,38 @@
+/**
+ * RFC-025 §5.5 — mission envelope.
+ *
+ * The envelope is the unit of authority: `uploadMission` prepares and commits
+ * it, `startMission` is authorized against its digest, and RFC-023 enforces its
+ * speed/duration/altitude bounds from the prepared command. A start that
+ * references a different plan than the one authorized fails closed.
+ */
+export interface Waypoint {
+    latitudeDeg: number;
+    longitudeDeg: number;
+    altitudeMetres: number;
+}
+export interface Geofence {
+    latitudeDeg: number;
+    longitudeDeg: number;
+    radiusMetres: number;
+}
+export interface MissionEnvelope {
+    envelopeId: string;
+    /** ResourceId key of the target vehicle. */
+    vehicle: string;
+    waypoints: readonly Waypoint[];
+    /** Altitude ceiling, in metres (decimal string). */
+    maxAltitudeMetres: string;
+    /** Ground-speed ceiling, in m/s (decimal string). */
+    maxSpeedMetresPerSecond: string;
+    /** Mission wall-clock ceiling, in seconds (decimal string). */
+    maxDurationSeconds: string;
+    geofence?: Geofence;
+}
+/** Great-circle distance between two WGS-84 points, in metres. */
+export declare function distanceMetres(a: Waypoint, b: Waypoint): number;
+/** Canonical digest of the authorized plan. */
+export declare function envelopeDigest(envelope: MissionEnvelope): string;
+/** Structural and physical validation; returns human-readable issues. */
+export declare function validateMissionEnvelope(envelope: MissionEnvelope): string[];
+export declare function assertValidMissionEnvelope(envelope: MissionEnvelope): void;

package/dist/envelope.js

@@ -0,0 +1,92 @@
+/**
+ * RFC-025 §5.5 — mission envelope.
+ *
+ * The envelope is the unit of authority: `uploadMission` prepares and commits
+ * it, `startMission` is authorized against its digest, and RFC-023 enforces its
+ * speed/duration/altitude bounds from the prepared command. A start that
+ * references a different plan than the one authorized fails closed.
+ */
+import { hashCanonical } from '@totemsdk/act-core';
+const EARTH_RADIUS_METRES = 6371000;
+/** Great-circle distance between two WGS-84 points, in metres. */
+export function distanceMetres(a, b) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(b.latitudeDeg - a.latitudeDeg);
+    const dLon = toRad(b.longitudeDeg - a.longitudeDeg);
+    const lat1 = toRad(a.latitudeDeg);
+    const lat2 = toRad(b.latitudeDeg);
+    const h = Math.sin(dLat / 2) ** 2 +
+        Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+    return 2 * EARTH_RADIUS_METRES * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+/** Canonical digest of the authorized plan. */
+export function envelopeDigest(envelope) {
+    return hashCanonical('TOTEM_ACT_MAVLINK_MISSION_ENVELOPE_V1', {
+        envelopeId: envelope.envelopeId,
+        vehicle: envelope.vehicle,
+        waypoints: envelope.waypoints.map((waypoint) => ({
+            latitudeDeg: waypoint.latitudeDeg,
+            longitudeDeg: waypoint.longitudeDeg,
+            altitudeMetres: waypoint.altitudeMetres,
+        })),
+        maxAltitudeMetres: envelope.maxAltitudeMetres,
+        maxSpeedMetresPerSecond: envelope.maxSpeedMetresPerSecond,
+        maxDurationSeconds: envelope.maxDurationSeconds,
+        geofence: envelope.geofence
+            ? {
+                latitudeDeg: envelope.geofence.latitudeDeg,
+                longitudeDeg: envelope.geofence.longitudeDeg,
+                radiusMetres: envelope.geofence.radiusMetres,
+            }
+            : null,
+    });
+}
+function positive(value) {
+    return Number.isFinite(Number(value)) && Number(value) > 0;
+}
+/** Structural and physical validation; returns human-readable issues. */
+export function validateMissionEnvelope(envelope) {
+    const issues = [];
+    if (envelope.envelopeId.trim() === '')
+        issues.push('envelopeId is required');
+    if (envelope.vehicle.trim() === '')
+        issues.push('vehicle is required');
+    if (envelope.waypoints.length === 0)
+        issues.push('at least one waypoint is required');
+    if (envelope.waypoints.length > 100)
+        issues.push('mission exceeds the 100-waypoint limit');
+    if (!positive(envelope.maxAltitudeMetres))
+        issues.push('maxAltitudeMetres must be positive');
+    if (!positive(envelope.maxSpeedMetresPerSecond))
+        issues.push('maxSpeedMetresPerSecond must be positive');
+    if (!positive(envelope.maxDurationSeconds))
+        issues.push('maxDurationSeconds must be positive');
+    const maxAltitude = Number(envelope.maxAltitudeMetres);
+    for (const [index, waypoint] of envelope.waypoints.entries()) {
+        if (!Number.isFinite(waypoint.latitudeDeg) || waypoint.latitudeDeg < -90 || waypoint.latitudeDeg > 90) {
+            issues.push(`waypoint ${index} latitude is out of range`);
+        }
+        if (!Number.isFinite(waypoint.longitudeDeg) || waypoint.longitudeDeg < -180 || waypoint.longitudeDeg > 180) {
+            issues.push(`waypoint ${index} longitude is out of range`);
+        }
+        if (!Number.isFinite(waypoint.altitudeMetres) || waypoint.altitudeMetres < 0) {
+            issues.push(`waypoint ${index} altitude is invalid`);
+        }
+        else if (waypoint.altitudeMetres > maxAltitude) {
+            issues.push(`waypoint ${index} altitude ${waypoint.altitudeMetres} m exceeds the envelope ceiling ${maxAltitude} m`);
+        }
+        if (envelope.geofence) {
+            const distance = distanceMetres({ latitudeDeg: envelope.geofence.latitudeDeg, longitudeDeg: envelope.geofence.longitudeDeg, altitudeMetres: 0 }, waypoint);
+            if (distance > envelope.geofence.radiusMetres) {
+                issues.push(`waypoint ${index} is ${Math.round(distance)} m from the geofence centre (limit ${envelope.geofence.radiusMetres} m)`);
+            }
+        }
+    }
+    return issues;
+}
+export function assertValidMissionEnvelope(envelope) {
+    const issues = validateMissionEnvelope(envelope);
+    if (issues.length > 0) {
+        throw new Error(`invalid mission envelope '${envelope.envelopeId}': ${issues.join('; ')}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * RFC-025 — governed MAVLink / autonomous flight profile.
+ *
+ * `@totemsdk/act-mavlink` authorizes a bounded mission envelope; the connector
+ * (`@totemsdk/edge-mavlink`) carries the wire frames and the autopilot owns
+ * stabilization, failsafes and the real-time loop.
+ */
+export { MavlinkTransportError, assertEnvelopeBinding, } from './transport.js';
+export type { MavlinkTransportPort, MissionStartRequest, MissionUploadRequest, MissionUploadResult, TelemetrySnapshot, } from './transport.js';
+export { assertValidMissionEnvelope, distanceMetres, envelopeDigest, validateMissionEnvelope, } from './envelope.js';
+export type { Geofence, MissionEnvelope, Waypoint } from './envelope.js';
+export { deriveFlightEffects } from './effects.js';
+export type { FlightLimits } from './effects.js';
+export { MAVLINK_PROTOCOL, createMavlinkProfile, mavlinkErrorTaxonomy, vehicleInterlocks, vehicleResource, vehicleResourceId, } from './profile.js';
+export type { FlightVehicle, MavlinkProfileOptions } from './profile.js';
+export { createMavlinkDefinitions } from './adapter.js';
+export type { MavlinkAdapterOptions } from './adapter.js';
+export { runMavlinkConformance } from './conformance.js';
+export type { MavlinkConformanceCheck, MavlinkConformanceOptions, MavlinkConformanceReport, } from './conformance.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * RFC-025 — governed MAVLink / autonomous flight profile.
+ *
+ * `@totemsdk/act-mavlink` authorizes a bounded mission envelope; the connector
+ * (`@totemsdk/edge-mavlink`) carries the wire frames and the autopilot owns
+ * stabilization, failsafes and the real-time loop.
+ */
+export { MavlinkTransportError, assertEnvelopeBinding, } from './transport.js';
+export { assertValidMissionEnvelope, distanceMetres, envelopeDigest, validateMissionEnvelope, } from './envelope.js';
+export { deriveFlightEffects } from './effects.js';
+export { MAVLINK_PROTOCOL, createMavlinkProfile, mavlinkErrorTaxonomy, vehicleInterlocks, vehicleResource, vehicleResourceId, } from './profile.js';
+export { createMavlinkDefinitions } from './adapter.js';
+export { runMavlinkConformance } from './conformance.js';

package/dist/profile.d.ts

@@ -0,0 +1,36 @@
+/**
+ * RFC-025 §5.4 / §5.9 — MAVLink flight profile.
+ *
+ * The vehicle is an asset addressed at its autopilot. Safe state is
+ * return-to-launch (a `fail-safe` in flight must never command a de-energize
+ * analogue). Interlocks enforce the vehicle's declared ceilings before
+ * authorization; safety-coded errors require the safe state and never retry.
+ */
+import { type DeviceErrorTaxonomy, type IndustrialProfile, type Interlock, type Resource, type ResourceId } from '@totemsdk/act-core';
+import { type MissionEnvelope } from './envelope.js';
+export declare const MAVLINK_PROTOCOL = "mavlink";
+export interface FlightVehicle {
+    vehicleId: string;
+    /** Ground-speed ceiling, in m/s (decimal string). */
+    maxSpeedMetresPerSecond: string;
+    /** Altitude ceiling, in metres (decimal string). */
+    maxAltitudeMetres: string;
+    /** Mission duration ceiling, in seconds (decimal string). */
+    maxDurationSeconds: string;
+    /** MAVLink addressing. */
+    systemId?: number;
+    componentId?: number;
+}
+export declare function vehicleResourceId(site: string, vehicleId: string): ResourceId;
+export declare function vehicleResource(site: string, vehicle: FlightVehicle): Resource;
+/** Interlocks enforcing the vehicle's declared envelope ceilings. */
+export declare function vehicleInterlocks(site: string, vehicle: FlightVehicle): Interlock[];
+/** MAVLink result codes → device error classification (RFC-011 §4.7). */
+export declare function mavlinkErrorTaxonomy(): DeviceErrorTaxonomy;
+export interface MavlinkProfileOptions {
+    site: string;
+    vehicles: readonly FlightVehicle[];
+}
+/** Data-only flight profile (definitions are supplied by the adapter). */
+export declare function createMavlinkProfile(options: MavlinkProfileOptions): IndustrialProfile;
+export type { MissionEnvelope };

package/dist/profile.js

@@ -0,0 +1,159 @@
+/**
+ * RFC-025 §5.4 / §5.9 — MAVLink flight profile.
+ *
+ * The vehicle is an asset addressed at its autopilot. Safe state is
+ * return-to-launch (a `fail-safe` in flight must never command a de-energize
+ * analogue). Interlocks enforce the vehicle's declared ceilings before
+ * authorization; safety-coded errors require the safe state and never retry.
+ */
+import { createDeviceErrorTaxonomy, } from '@totemsdk/act-core';
+import { distanceMetres } from './envelope.js';
+export const MAVLINK_PROTOCOL = 'mavlink';
+export function vehicleResourceId(site, vehicleId) {
+    return { site, area: 'flight', asset: vehicleId, point: 'autopilot' };
+}
+export function vehicleResource(site, vehicle) {
+    const id = vehicleResourceId(site, vehicle.vehicleId);
+    return {
+        id,
+        kind: 'controller',
+        addresses: [
+            {
+                protocol: MAVLINK_PROTOCOL,
+                endpoint: `system:${vehicle.systemId ?? 1}/component:${vehicle.componentId ?? 1}`,
+            },
+        ],
+        // Hold/land/return are deployment policy; return-to-launch is the default
+        // safe state. Never de-energize an airborne vehicle.
+        safeState: {
+            resourceId: id,
+            command: { action: 'flight:returnToLaunch' },
+        },
+        metadata: {
+            vehicleId: vehicle.vehicleId,
+            maxSpeedMetresPerSecond: vehicle.maxSpeedMetresPerSecond,
+            maxAltitudeMetres: vehicle.maxAltitudeMetres,
+            maxDurationSeconds: vehicle.maxDurationSeconds,
+        },
+    };
+}
+function numeric(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    if (value && typeof value === 'object' && 'value' in value) {
+        return numeric(value.value);
+    }
+    return undefined;
+}
+function ceilingInterlock(site, vehicle, id, parameter, ceiling, unit) {
+    const resourceId = vehicleResourceId(site, vehicle.vehicleId);
+    return {
+        id,
+        kind: 'precondition',
+        resources: [resourceId],
+        safeState: { resourceId, command: { action: 'flight:returnToLaunch' } },
+        evaluate({ parameters }) {
+            const requested = numeric(parameters[parameter]);
+            if (requested === undefined)
+                return { satisfied: true };
+            return requested <= Number(ceiling)
+                ? { satisfied: true }
+                : { satisfied: false, reason: `requested ${requested} ${unit} exceeds vehicle ceiling ${ceiling} ${unit}` };
+        },
+    };
+}
+/** Interlocks enforcing the vehicle's declared envelope ceilings. */
+export function vehicleInterlocks(site, vehicle) {
+    const resourceId = vehicleResourceId(site, vehicle.vehicleId);
+    const interlocks = [
+        ceilingInterlock(site, vehicle, `mavlink:speed-ceiling:${vehicle.vehicleId}`, 'maxSpeedMetresPerSecond', vehicle.maxSpeedMetresPerSecond, 'm/s'),
+        ceilingInterlock(site, vehicle, `mavlink:altitude-ceiling:${vehicle.vehicleId}`, 'maxAltitudeMetres', vehicle.maxAltitudeMetres, 'm'),
+        ceilingInterlock(site, vehicle, `mavlink:duration-ceiling:${vehicle.vehicleId}`, 'maxDurationSeconds', vehicle.maxDurationSeconds, 's'),
+    ];
+    // Geofence containment is dynamic: it depends on the waypoints in the
+    // prepared request, not only on scalar ceilings.
+    interlocks.push({
+        id: `mavlink:geofence:${vehicle.vehicleId}`,
+        kind: 'precondition',
+        resources: [resourceId],
+        safeState: { resourceId, command: { action: 'flight:returnToLaunch' } },
+        evaluate({ parameters }) {
+            const latitude = numeric(parameters.geofenceLatitudeDeg);
+            const longitude = numeric(parameters.geofenceLongitudeDeg);
+            const radius = numeric(parameters.geofenceRadiusMetres);
+            if (latitude === undefined || longitude === undefined || radius === undefined) {
+                return { satisfied: true };
+            }
+            const waypoints = parameters.waypoints;
+            if (!Array.isArray(waypoints))
+                return { satisfied: true };
+            for (const [index, waypoint] of waypoints.entries()) {
+                const candidate = waypoint;
+                const distance = distanceMetres({ latitudeDeg: latitude, longitudeDeg: longitude, altitudeMetres: 0 }, candidate);
+                if (distance > radius) {
+                    return {
+                        satisfied: false,
+                        reason: `waypoint ${index} is ${Math.round(distance)} m from the geofence centre (limit ${radius} m)`,
+                    };
+                }
+            }
+            return { satisfied: true };
+        },
+    });
+    return interlocks;
+}
+/** MAVLink result codes → device error classification (RFC-011 §4.7). */
+export function mavlinkErrorTaxonomy() {
+    const taxonomy = createDeviceErrorTaxonomy();
+    const classes = {
+        // Failsafe/geofence conditions require the safe state and never retry.
+        GEOFENCE_BREACH: 'safety',
+        FAILSAFE_TRIGGERED: 'safety',
+        BATTERY_LOW: 'safety',
+        CRITICAL_BATTERY: 'safety',
+        // Mission/protocol rejection — retrying the same plan cannot succeed.
+        MAV_MISSION_ERROR: 'permanent',
+        MAV_MISSION_UNSUPPORTED: 'permanent',
+        MAV_MISSION_UNSUPPORTED_FRAME: 'permanent',
+        MAV_MISSION_NO_SPACE: 'permanent',
+        MAV_MISSION_INVALID: 'permanent',
+        MAV_MISSION_INVALID_PARAM1: 'permanent',
+        MAV_MISSION_INVALID_PARAM2: 'permanent',
+        MAV_MISSION_INVALID_PARAM3: 'permanent',
+        MAV_MISSION_INVALID_PARAM4: 'permanent',
+        MAV_MISSION_INVALID_PARAM5_X: 'permanent',
+        MAV_MISSION_INVALID_PARAM6_Y: 'permanent',
+        MAV_MISSION_INVALID_PARAM7: 'permanent',
+        MAV_MISSION_DENIED: 'auth',
+        MAV_RESULT_UNSUPPORTED: 'permanent',
+        MAV_RESULT_FAILED: 'permanent',
+        MAV_RESULT_CANCELLED: 'permanent',
+        // Link/transport — retry under the same operation id is safe.
+        LINK_TIMEOUT: 'transient',
+        MAV_RESULT_IN_PROGRESS: 'transient',
+        TIMEOUT: 'transient',
+        // Authorization.
+        AUTHORIZATION_DENIED: 'auth',
+        ENVELOPE_MISMATCH: 'auth',
+    };
+    for (const [code, classification] of Object.entries(classes)) {
+        taxonomy.register(MAVLINK_PROTOCOL, code, classification);
+    }
+    return taxonomy;
+}
+/** Data-only flight profile (definitions are supplied by the adapter). */
+export function createMavlinkProfile(options) {
+    return {
+        id: 'mavlink',
+        version: 1,
+        resources: options.vehicles.map((vehicle) => vehicleResource(options.site, vehicle)),
+        interlocks: options.vehicles.flatMap((vehicle) => vehicleInterlocks(options.site, vehicle)),
+        errorTaxonomy: mavlinkErrorTaxonomy(),
+        capabilities: ['industrial:action', 'industrial:read', 'transport:mavlink'],
+        recipes: [],
+        definitions: [],
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,56 @@
+/**
+ * RFC-025 §5.2 — MAVLink transport port.
+ *
+ * The caller injects a MAVLink client (SDK, bridge, or simulator). This package
+ * owns mission authority, bounded execution and evidence; the autopilot owns
+ * stabilization, failsafes and the real-time loop.
+ *
+ * `startMission` carries the authorized envelope digest so a transport can
+ * refuse to start a mission that differs from the one that was authorized.
+ */
+import { type MissionEnvelope, type Waypoint } from './envelope.js';
+export interface MissionUploadRequest {
+    envelopeId: string;
+    envelopeDigest: string;
+    waypoints: readonly Waypoint[];
+}
+export interface MissionUploadResult {
+    /** Autopilot-assigned mission id (the reconciliation handle). */
+    missionId: string;
+}
+export interface MissionStartRequest {
+    missionId: string;
+    envelopeDigest: string;
+}
+export interface TelemetrySnapshot {
+    /** ISO-8601 timestamp from the autopilot. */
+    timestamp: string;
+    latitudeDeg: number;
+    longitudeDeg: number;
+    altitudeMetres: number;
+    groundspeedMetresPerSecond: number;
+    batteryPercent?: number;
+    waypointIndex?: number;
+    missionFinished?: boolean;
+    armed?: boolean;
+}
+export interface MavlinkTransportPort {
+    uploadMission(request: MissionUploadRequest): Promise<MissionUploadResult>;
+    startMission(request: MissionStartRequest): Promise<void>;
+    hold(): Promise<void>;
+    returnToLaunch(): Promise<void>;
+    land(): Promise<void>;
+    /** Telemetry readback used for reconciliation; must originate from the vehicle. */
+    readTelemetry(): Promise<TelemetrySnapshot>;
+    /** Optional push path for telemetry. */
+    onTelemetry?(handler: (telemetry: TelemetrySnapshot) => void): () => void;
+}
+export declare class MavlinkTransportError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * A start must reference the exact plan that was authorized. A digest that does
+ * not match the envelope fails closed before dispatch.
+ */
+export declare function assertEnvelopeBinding(envelope: MissionEnvelope, digest: string): void;

package/dist/transport.js

@@ -0,0 +1,28 @@
+/**
+ * RFC-025 §5.2 — MAVLink transport port.
+ *
+ * The caller injects a MAVLink client (SDK, bridge, or simulator). This package
+ * owns mission authority, bounded execution and evidence; the autopilot owns
+ * stabilization, failsafes and the real-time loop.
+ *
+ * `startMission` carries the authorized envelope digest so a transport can
+ * refuse to start a mission that differs from the one that was authorized.
+ */
+import { envelopeDigest } from './envelope.js';
+export class MavlinkTransportError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'MavlinkTransportError';
+        this.code = code;
+    }
+}
+/**
+ * A start must reference the exact plan that was authorized. A digest that does
+ * not match the envelope fails closed before dispatch.
+ */
+export function assertEnvelopeBinding(envelope, digest) {
+    const expected = envelopeDigest(envelope);
+    if (digest !== expected) {
+        throw new MavlinkTransportError('EnvelopeMismatch', `envelope digest mismatch for '${envelope.envelopeId}' (authorized ${digest}, prepared ${expected})`);
+    }
+}

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@totemsdk/act-mavlink",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Governed MAVLink autonomous-flight profile for Totem — bounded mission envelopes, telemetry reconciliation and conformance on the act-core runtime",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@totemsdk/act-core": "^0.5.0",
+    "@totemsdk/agent-policy": "^0.4.0",
+    "@totemsdk/edge": "^1.5.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^30.4.2",
+    "jest-environment-node": "^30.0.0",
+    "jest-runtime": "^30.5.2",
+    "ts-jest": "^29.0.0",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "Apache-2.0",
+  "author": "Totem SDK",
+  "homepage": "https://docs.totem.ing",
+  "bugs": {
+    "url": "https://github.com/Totem-Edge/totem-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Totem-Edge/totem-sdk.git",
+    "directory": "packages/act-mavlink"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "mavlink",
+    "drone",
+    "flight",
+    "mission",
+    "geofence",
+    "governed-action",
+    "act-core"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json && node -e \"require('fs').writeFileSync('dist/cjs/package.json', JSON.stringify({type:'commonjs'})+'\\n')\"",
+    "clean": "rm -rf dist",
+    "test": "jest --config ../../tests/jest/act-mavlink.cjs",
+    "test:integration": "node --test ../../tests/qualification/act-mavlink/integration.test.mjs",
+    "lint": "eslint src --max-warnings 0"
+  }
 }