tassello 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+Tassello follows [semantic versioning](https://semver.org): before 1.0, a new minor version may
+change the plugin API (`tassello/sdk`, `tassello/server`, `tassello/vite`), as noted here.
+
+## 0.1.0
+
+The first release, from the Dieletrikbot's web dashboard.
+
+- Panels of widgets on a grid, edited in the browser, with layouts of their own for tablets and
+  phones.
+- Widgets: Teleop, Navigation, Robot Model, Arm Teleop, Camera, Image Viewer, Button,
+  Application Manager.
+- Plugins: widgets loaded at run time (`tassello/sdk`, built with `tassello/vite`), server sides
+  (`tassello/server`), defaults for any widget's properties, example panels. Found on the command
+  line, in the ament index (`tassello_plugins`) and as `tassello-plugin-*` npm packages.
+- Generic ROS access from the page: publish, call services, subscribe to topics, TF.
+- `tassello create-plugin`.

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,241 @@
-# Temporary Holding Version
+# Tassello
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**A web dashboard for ROS 2 robots.** Drive the robot, send it navigation goals, see it move in 3D,
+watch its cameras, run commands on it and manage its services from any browser on the network,
+phones included. Arrange it all in the browser, as panels of widgets, and extend it with plugins.
+
+*Tassello* is Italian for a mosaic tile, and for a wall plug: the dashboard is a mosaic of widgets,
+and plugins add more.
+
+- **Panels of widgets** on a grid: add, move and resize them in the browser, no code or config files.
+- **Every device**: a desktop canvas, and layouts of their own for tablets and phones.
+- **Built in**: teleop pads, a Nav2 map with goals, the robot's URDF in 3D, an arm jogger, cameras,
+  images, command buttons and a systemd application manager.
+- **Plugins**: widgets of your own, with server-side code if they need it, as npm or ROS packages.
+- **One process**: a ROS 2 node in Node.js. Nothing to install on the robot but Node.js.
+
+## Install
+
+Tassello runs on the robot (or any machine on its ROS network) and needs:
+
+- ROS 2: Humble, Jazzy, Kilted or Lyrical, on x64 or arm64 (e.g. a Raspberry Pi), for which
+  [rclnodejs](https://github.com/RobotWebTools/rclnodejs) ships prebuilt binaries;
+- Node.js 22 or newer, and npm.
+
+```bash
+npm install -g tassello
+```
+
+Then, with your ROS 2 setup sourced:
+
+```bash
+source /opt/ros/jazzy/setup.bash
+tassello
+```
+
+and open `http://<robot>:8080`. The first start creates the panels directory with two example
+panels, Teleoperation and Navigation.
+
+```text
+tassello [options] [--ros-args ...]
+
+  -p, --port <port>         HTTP port (8080)
+      --host <address>      the address to listen on (all of them)
+      --panels-dir <dir>    where the panels are kept (~/.local/share/tassello/panels)
+      --plugin <plugin>     loads a plugin: a folder, or an installed package's name. Repeatable
+      --no-discover         loads only those plugins, not the installed ones
+      --node-name <name>    the ROS node's name (tassello)
+```
+
+ROS arguments go after `--ros-args`, e.g. `tassello --ros-args -p use_sim_time:=true`. The port
+and the panels directory are also the node's parameters `port` and `panels_dir`.
+
+### As a service
+
+To start it at boot, a systemd unit like this one (as the user the commands should run as):
+
+```ini
+[Unit]
+Description=Tassello robot dashboard
+After=network-online.target
+
+[Service]
+User=robot
+ExecStart=/bin/bash -c 'source /opt/ros/jazzy/setup.bash && exec tassello'
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+```
+
+## Using it
+
+The page shows one **panel** at a time: a canvas of fixed-size cells on which **widgets** lie,
+each spanning as many cells as needed. A panel is made for a task (teleoperation, navigation,
+manipulation, ...) and the top bar switches between them. It has two modes:
+
+- **View**: the widgets work: drive, watch, press.
+- **Edit**: add widgets (**Add widget**), drag them to move them, drag their corner to resize
+  them, click one to edit its properties in the side panel, and create, rename, duplicate or
+  delete panels (**⋯**). Every change is saved as you make it; **Ctrl+Z** undoes it, the
+  arrow keys move the selected widget and **Delete** removes it.
+
+The URL names the panel (`#/teleoperation`), so a panel can be bookmarked, e.g. on a phone's
+home screen. Each panel is a JSON file, `<panels dir>/<id>.json`: copy it to copy the panel to
+another robot.
+
+### Phones and tablets
+
+A panel has a layout per kind of device, chosen by the width of the window: **desktop** (from
+1100 px), **tablet** (from 640 px) and **phone**. The widgets and their properties are the same on
+all of them; only where they are differs.
+
+- On a desktop the board is a canvas of fixed cells, which scrolls both ways.
+- Tablets have 12 columns and phones 6, stretched to the width of the screen: a layout looks the
+  same on every phone, and the page only scrolls down.
+
+Until arranged, a tablet's or phone's layout is made from the desktop's: the widgets in its reading
+order, narrowed to the columns (keeping their shape), side by side where they fit. In edit mode the
+device buttons of the top bar show each device's layout, at its width: moving or resizing a widget
+there arranges the layout for that device, and the eye button hides a widget on it (e.g. the 3D
+model on phones). **Back to automatic** forgets the device's own layout. Widgets added later go
+after the others on the devices already arranged.
+
+## Widgets
+
+| Widget | What it does |
+|---|---|
+| **Teleop** | Publishes velocity commands (`Twist` or `TwistStamped`) while its pads are held: one pad (x, z), or two in omnidirectional mode (x and y, z). Then one zero, and nothing, so that the lower priorities of a twist_mux, e.g. navigation, take over again |
+| **Navigation** | The map, optionally the global and local costmaps and the planned path, and the robot where TF puts it. Its tools set the pose estimate and send navigation goals, as RViz's do: press where the robot is or should go, drag towards where it faces. Pan, zoom, fit the map or follow the robot |
+| **Robot Model** | The robot in 3D, from its URDF and meshes, posed by the joint states. The links of moving joints turn orange, with an arrow at the joint in the direction of the motion |
+| **Arm Teleop** | Jogs an arm driven by ros2_control `JointTrajectoryController`s: a slider per joint, or pads moving the end effector in a straight line (damped least squares on the URDF's kinematics, collision checked by MoveIt's move_group when it runs) |
+| **Camera** | An image topic, raw (`sensor_msgs/Image`) or compressed (`sensor_msgs/CompressedImage`) |
+| **Image Viewer** | A static image: a file of the robot, typed (`/…`, `~/…`, `package://…`) or picked by browsing its folders, or an image uploaded from the page's device |
+| **Button** | Runs a bash command on the robot, showing its output. Takes its running colour until the command finishes, on every page showing it; pressing it again stops the command |
+| **Application Manager** | The robot's systemd services matching a name: their state, whether they start at boot, buttons to start, stop and restart them, and their journal |
+
+Their properties (topics, frames, speeds, colours, ...) are edited in the side panel of edit mode.
+
+Notes on some of them:
+
+- **Navigation** publishes goals as `geometry_msgs/PoseStamped` (`/goal_pose`, which Nav2's
+  bt_navigator follows) and pose estimates as `geometry_msgs/PoseWithCovarianceStamped`
+  (`/initialpose`, with RViz's covariance, which AMCL starts from). Layers in another frame, like
+  Nav2's local costmap, are placed in the map frame by TF.
+- **Robot Model** loads the meshes of the description from the robot's ROS packages
+  (`package://` paths), which the server serves compressed. three.js is only fetched by the pages
+  showing one.
+- **Arm Teleop** streams its controllers one-point trajectories just ahead of the arm, 20 times
+  a second: when the stream stops, the arm stops at the last point. A joint stays within the
+  URDF's limits, or those of an optional *calibration state*: a `std_msgs/String` topic whose
+  JSON a robot's hardware interface may publish:
+
+  ```json
+  {
+    "active": true,
+    "calibrating": false,
+    "problem": null,
+    "joints": [
+      { "name": "joint_1", "has_motor": true, "located": true, "drivable": true,
+        "lower": -1.5, "upper": 1.5, "allowed_lower": -1.4, "allowed_upper": 1.4 }
+    ]
+  }
+  ```
+
+  A drivable joint moves within `allowed_lower`..`allowed_upper`; others do not move, and the
+  widget says why (no motor, not located, no limits).
+- **Button** commands run with `bash -c`, as the server's user and in its environment (the
+  sourced ROS setup), from the home directory.
+- **Application Manager** lists the services of the system's and the user's service managers. It
+  acts as the server's user: for the system's services, give that user the right to manage them,
+  e.g. a polkit rule allowing it to start, stop and restart `myrobot-*` units. To read systemd's
+  own journal lines, the user must be in the `systemd-journal` group.
+- **Image Viewer** reads only images (PNG, JPEG, GIF, WebP, BMP, SVG). Uploads are kept next to
+  the panels (`~/.local/share/tassello/images`). Images are served sandboxed: an SVG cannot run
+  scripts in the dashboard.
+
+## Plugins
+
+A plugin adds widgets, and server-side code if they need it, to any Tassello: an npm package or
+a folder whose `package.json` says what it has. Robots get their own controls this way without
+forking the dashboard: a gripper, a battery gauge, a calibration procedure, a custom service.
+
+```bash
+tassello create-plugin my-robot      # a plugin with an example widget and server side
+cd my-robot && npm install && npm run build
+tassello --plugin .
+```
+
+Plugins are found:
+
+- on the command line: `--plugin <folder or package>`;
+- in ROS packages of the sourced workspaces that register a `tassello_plugins` resource in the
+  ament index, so that a robot's ROS package can carry its own;
+- as npm packages named `tassello-plugin-*` (or `@scope/tassello-plugin-*`), installed next to
+  Tassello (e.g. both with `npm install -g`) or in the working directory's `node_modules`.
+
+A plugin can also give Tassello's widgets new defaults (a robot's topic names and speed limits)
+and ship example panels. See **[docs/plugins.md](docs/plugins.md)**.
+
+## Security
+
+Tassello has no login. **Anyone who can open the page can drive the robot, run any command as
+the server's user and read its images**: keep it on a network you trust, or behind a reverse
+proxy with authentication (it serves everything under `/`, its WebSocket at `/ws`).
+
+## How it works
+
+```
+ browser ── HTTP: page, /api (panels, topics, files), /plugins ────┐
+         └─ WebSocket /ws: twists, poses, images, maps, TF, ───────┤
+                           topics, services, commands, plugins     └─ server (Node.js, one ROS node)
+                                                                        ├─ rclnodejs: ROS
+                                                                        ├─ sharp: raw images to JPEG, maps to PNG
+                                                                        ├─ bash: the buttons' commands
+                                                                        └─ the plugins' server sides
+```
+
+Safety and bandwidth are the server's concern:
+
+- A teleop widget streams its command while a pad is held. When the stream stops without its
+  final zero (page closed, network lost), the server publishes it after 0.5 s. A page that stops
+  answering the server's pings is dropped within 20 s. Arm jogs stop the same way.
+- Each camera or map widget gets one frame at a time, the latest, and the next once it has drawn
+  it: a slow network or phone skips frames instead of lagging behind. Raw images are scaled down
+  and compressed once per frame, however many pages watch them. Maps are coloured and compressed
+  on the server and kept up to date with their `<topic>_updates`, subscribed with the durability
+  of their publishers, so latched maps arrive.
+- Topics are subscribed once, whatever the number of pages, with the type and QoS of their
+  publishers; TF only while a page shows the robot.
+- A button runs the command saved in its panel, never one sent by the page.
+
+## Developing
+
+```bash
+git clone https://github.com/AntoBrandi/tassello && cd tassello
+npm install
+npm run build        # the page (dist/www), the server and the plugin API (dist/)
+npm run server       # the server from its sources, with ROS sourced: http://localhost:8080
+npm run dev          # the page, reloaded on every change, at http://localhost:5173
+npm run typecheck
+npm test
+```
+
+`npm run dev` forwards the API and the WebSocket to `DASHBOARD_SERVER`, `http://localhost:8080`
+by default: point it at a robot to work on the page against the real thing.
+
+- `src/client/`: the page, React built by Vite. `widgets/` holds the widgets, `board/` the grid,
+  `sdk/` what plugins import as `tassello/sdk`.
+- `src/server/`: the server, TypeScript that Node.js runs as is in development and that the
+  build compiles to JavaScript for the package. `api.ts` is what plugins import as
+  `tassello/server`.
+- `src/shared/`: what both sides agree on: the panels and the WebSocket protocol (`protocol.ts`).
+- `src/vite/`: the Vite plugin that builds plugins, `tassello/vite`.
+- `template/`: what `tassello create-plugin` copies.
+
+To add a widget to Tassello itself, write it in `src/client/widgets/` like `ButtonWidget.tsx` and
+list it in `registry.ts`. Never change a widget's `type`: the panels store it.
+
+## License
+
+[Apache 2.0](LICENSE)

package/dist/server/api.d.ts

@@ -0,0 +1,27 @@
+import type rclnodejs from 'rclnodejs';
+import type { Logger } from './util.ts';
+export type { Logger };
+export interface PluginSession {
+    readonly id: string;
+}
+export type RequestHandler = (params: unknown, session: PluginSession) => unknown;
+export type StreamHandler = (params: unknown, emit: (data: unknown) => void, session: PluginSession) => (() => void) | void;
+export interface CommandWidget {
+    property: string;
+    fallback?: string;
+}
+export interface PluginContext {
+    readonly name: string;
+    readonly dir: string;
+    readonly node: rclnodejs.Node;
+    readonly rclnodejs: typeof rclnodejs;
+    readonly logger: Logger;
+    handle(method: string, handler: RequestHandler): void;
+    stream(name: string, handler: StreamHandler): void;
+    commandWidget(type: string, command: CommandWidget): void;
+    onShutdown(callback: () => void | Promise<void>): void;
+}
+export interface TasselloPlugin {
+    activate(context: PluginContext): void | Promise<void>;
+}
+export declare function definePlugin(plugin: TasselloPlugin): TasselloPlugin;

package/dist/server/api.js

@@ -0,0 +1,20 @@
+// The server side of a Tassello plugin, published as `tassello/server`: what a
+// plugin's server module exports, and what it is given. A plugin extends the
+// server with requests and streams its widgets reach through the page's
+// connection (connection.request and connection.subscribePlugin of
+// `tassello/sdk`), and with widgets that run commands.
+//
+//   import type { TasselloPlugin } from 'tassello/server';
+//
+//   export default {
+//     activate(ctx) {
+//       ctx.handle('greet', (params) => `Hello ${String(params)} from ${ctx.node.name()}`);
+//     },
+//   } satisfies TasselloPlugin;
+//
+// Importing only types keeps the module free of `tassello` at run time: the
+// server gives the plugin everything it needs, the ROS node included.
+// For plugins that prefer a function to `satisfies TasselloPlugin`
+export function definePlugin(plugin) {
+    return plugin;
+}

package/dist/server/arm.d.ts

@@ -0,0 +1,79 @@
+import type rclnodejs from 'rclnodejs';
+import { type ArmIk, type ArmUpdate } from '../shared/protocol.ts';
+import { Kinematics } from './kinematics.ts';
+import type { Topics } from './topics.ts';
+import { type Logger } from './util.ts';
+interface Vector {
+    x: number;
+    y: number;
+    z: number;
+}
+interface ServiceClient {
+    isServiceServerAvailable(): boolean;
+    sendRequestAsync(request: unknown, options?: {
+        timeout?: number;
+    }): Promise<unknown>;
+}
+export interface ArmOptions {
+    controllers: string[];
+    jointStatesTopic: string;
+    descriptionTopic: string;
+    calibrationTopic: string;
+}
+export interface ArmJogInput {
+    joints: Record<string, number>;
+    cartesian: Vector;
+    ik: ArmIk;
+}
+interface Controller {
+    name: string;
+    joints: string[] | null;
+    error: string | null;
+}
+export declare class Arm {
+    readonly node: rclnodejs.Node;
+    readonly topics: Topics;
+    readonly logger: Logger;
+    private readonly clients;
+    private readonly trajectoryPublishers;
+    constructor(node: rclnodejs.Node, topics: Topics, logger: Logger);
+    watch(options: ArmOptions, send: (update: Omit<ArmUpdate, 'type' | 'id'>) => void): ArmWatcher;
+    client(type: string, name: string): ServiceClient;
+    publishTrajectory(controller: string, joints: string[], positions: number[], ahead: number, start: number[] | null): void;
+}
+export declare class ArmWatcher {
+    private readonly arm;
+    private readonly options;
+    private readonly send;
+    private readonly unwatch;
+    private disposed;
+    readonly controllers: Controller[];
+    readonly positions: Map<string, number>;
+    private urdf;
+    private urdfKinematics;
+    private calibration;
+    private topicProblems;
+    private jog;
+    jogStatus: ArmUpdate['jog'];
+    private lastSent;
+    private sendTimer;
+    private lastSentAt;
+    constructor(arm: Arm, options: ArmOptions, send: (update: Omit<ArmUpdate, 'type' | 'id'>) => void);
+    dispose(): void;
+    input(input: ArmJogInput): void;
+    setJogStatus(state: ArmUpdate['jog']['state'], message?: string): void;
+    range(name: string): {
+        lower: number | null;
+        upper: number | null;
+    };
+    refusal(name: string): string | null;
+    kinematics(): Kinematics | null;
+    controllerOf(joint: string): Controller | undefined;
+    private calibrationJoint;
+    private watchTopic;
+    private onJointStates;
+    private resolve;
+    private changed;
+    private update;
+}
+export {};