@synapticon/motion-master-client 6.0.0-alpha.64 → 6.0.0-alpha.66

package/dist/generated/Api.d.ts

@@ -1,4 +1,4 @@
-import { AlStatusCode, BrakeState, Cia402Status, DcSyncStatus, DeviceDiagnostics, DeviceParameter, EscRegister, EsiParseResult, FoeErrorCode, GameLoopHealth, MailboxErrorCode, Monitoring, ObjectDataTypeInfo, OutputStageResult, ParameterCacheEntry, PdoMapping, PdoMappingRequest, ProcedureListing, ProcedureRequest, ProcedureSnapshot, ProcessDataWatchdog, ProcessImageObject, SdoAbortCode, SlaveConfig, SlaveInformationInterface, UserCacheListing } from "./data-contracts.js";
+import { AlStatusCode, BrakeState, Cia402Status, DcSyncStatus, DeviceDiagnostics, DeviceFile, DeviceParameter, EscRegister, EsiParseResult, FirmwarePackageName, FoeErrorCode, GameLoopHealth, HrdRecording, MailboxErrorCode, Monitoring, ObjectDataTypeInfo, OutputStageResult, ParameterCacheEntry, PdoMapping, PdoMappingRequest, ProcedureListing, ProcedureRequest, ProcedureSnapshot, ProcessDataWatchdog, ProcessImageObject, SdoAbortCode, SlaveConfig, SlaveInformationInterface, UserCacheListing } from "./data-contracts.js";
 import { HttpClient, RequestParams } from "./http-client.js";
 export declare class Api<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {
     /**
@@ -671,7 +671,7 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      */
     listProcedures: (slavePosition: number, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<ProcedureListing[], void>>;
     /**
-     * @description Starts the named procedure and returns as soon as the run is under way — this does **not** wait for it to finish. Poll `GET` on the same path for its outcome, or `DELETE` to cancel it. The request body carries the procedure's parameters; which fields it accepts (and whether it needs any at all) is per procedure, so consult the descriptor from `GET /api/devices/{slavePosition}/procedures`. A procedure that takes no parameters may be started with no body. Only one procedure may run on a device at a time; a second start is refused with 409 while the first is in flight. Most procedures require an active mailbox, so the device must be in PRE-OP, SAFE-OP or OP. A run the drive answers with an error is not a failure of *this* request — it is reported in the snapshot as a failed run.
+     * @description Starts the named procedure and returns as soon as the run is under way — this does **not** wait for it to finish. Poll `GET` on the same path for its outcome, or `DELETE` to cancel it. The request body carries the procedure's parameters, and each descriptor from `GET /api/devices/{slavePosition}/procedures` reports its own in `parameters` — name, type, bounds, default, and whether it is required — which is enough to build a form for any procedure without hard-coding one per name. A procedure that takes no parameters may be started with no body. Only one procedure may run on a device at a time; a second start is refused with 409 while the first is in flight. Most procedures require an active mailbox, so the device must be in PRE-OP, SAFE-OP or OP. A run the drive answers with an error is not a failure of *this* request — it is reported in the snapshot as a failed run.
      *
      * @name StartProcedure
      * @summary Start a procedure on a device
@@ -702,6 +702,20 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      * @request GET:/api/devices/{slavePosition}/brake
      */
     getBrake: (slavePosition: number, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<BrakeState, void>>;
+    /**
+     * @description Reads the files the `hrd-streaming` procedure recorded, concatenates them in order and decodes them into samples. Run that procedure first; this endpoint only reads what is already on the drive. **`data` is required and must match what was recorded.** Nothing on the drive says which signal its files hold, so the wrong selection reinterprets the same bytes as a different layout and returns plausible nonsense. The procedure's `configure-stream` step reports the selection it used for exactly this reason. Samples travel positionally — `columns` names the fields of each row, once, the way a monitoring topic ships its parameter order once — because a full recording is up to ten thousand rows. `trailingBytes` is what was left over past the last whole sample: the drive allocates its files in fixed-size blocks, so a recording that does not fill the last block ends in padding rather than data. Answers **JSON or CSV**, chosen by the `Accept` header. CSV is the same numbers in the same column order, one header row then one row per sample — a file to open in a spreadsheet rather than JSON to read, which for ten thousand rows is usually what is wanted. Values are decoded, not raw: `velocityRpm` is converted out of the file's Q15 fixed point (exactly — multiply by 32768 to recover the stored integer), while `torquePermil` and the encoder's `raw` word are the file's own values. Blocks for the transfer, which is up to five 8 KB FoE reads plus the listing.
+     *
+     * @name ReadHrdRecording
+     * @summary Read back a drive's high resolution data recording
+     * @request GET:/api/devices/{slavePosition}/hrd
+     */
+    readHrdRecording: (slavePosition: number, query: {
+        /**
+         * Which layout the files hold — the same selection the recording was made with.
+         * @example "encoder-raw"
+         */
+        data: "encoder-raw" | "system-identification";
+    }, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<HrdRecording, void>>;
     /**
      * @description Writes "disengaged" to the brake state object (0x2004:07) and waits the drive's pull time (0x2004:03) plus `settle` before answering, because the firmware blocks motion — and motion-related OS commands — until the pull time expires. Answers with the brake state read back. **The release only actually happens while the drive is in OP ENABLED.** In any other state the write merely energises the brake output (phase D). Note also that entering OP ENABLED releases the brake automatically in normal operation but **not** in diagnostics mode, where the master owns the brake — which is why a diagnostics procedure has to call this. **On a pin brake this moves the shaft**: the controller raises current progressively until the load has lifted off the pin by the minimum displacement (0x2004:08), reversing direction if it reaches the current ceiling (0x2004:09, a percentage of rated current) first. Check `releaseMovesShaft` on `GET .../brake`. Brake release is open-loop — nothing confirms the brake let go — so the wait is the only margin there is. A brake whose release strategy is `manualOutputVoltage` is left alone and the returned state says so; that is not an error. **A released brake stays released**: nothing re-engages it for you, so on a vertical or loaded axis engage it again when you are done.
      *
@@ -734,58 +748,6 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
          */
         settle?: number;
     }, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<BrakeState, void>>;
-    /**
-     * @description Commands the device to persist its current parameters (the generic CANopen "store parameters" object 0x1010:01) and waits for confirmation. The server writes the ASCII "save" signature, waits a fixed settle (~1 s) for the drive to begin the flash write, then polls 0x1010:01 until it reads back 1 ("save completed"). Because a store in progress can leave the mailbox briefly unresponsive, a poll that does not yet confirm — a value mismatch or a transient read error alike — is retried up to `retries` more times, `interval` apart. The call blocks until the store is confirmed or the retry budget is exhausted (up to a few seconds); the device's mailbox must be active (PRE-OP/SAFE-OP/OP).
-     *
-     * @name StoreParameters
-     * @summary Store a device's parameters to non-volatile memory
-     * @request POST:/api/devices/{slavePosition}/store-parameters
-     */
-    storeParameters: (slavePosition: number, query?: {
-        /**
-         * Maximum number of extra confirmation polls after the first.
-         * @min 0
-         * @default 10
-         * @example 5
-         */
-        retries?: number;
-        /**
-         * Delay between confirmation polls, in milliseconds.
-         * @min 0
-         * @default 500
-         * @example 500
-         */
-        interval?: number;
-    }, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<void, void>>;
-    /**
-     * @description Commands the device to restore its default parameters (the generic CANopen "restore default parameters" object 0x1011) for the selected `group`, and waits for confirmation. The server writes the ASCII "load" signature to the matching 0x1011 sub-entry, waits a fixed settle (~1 s) for the device to begin, then polls that sub-entry until it reads back 1 ("restore completed"), retrying a poll that does not yet confirm — a value mismatch or a transient read error alike — up to `retries` more times, `interval` apart. The call blocks until the restore is confirmed or the retry budget is exhausted (up to a few seconds); the device's mailbox must be active (PRE-OP/SAFE-OP/OP). **Destructive:** this overwrites the selected group's parameter values in the device's volatile memory with the device's defaults, replacing the current live values (not the persisted store). Which values it touches, and whether it takes effect immediately or after the next reset, is device-specific.
-     *
-     * @name RestoreDefaultParameters
-     * @summary Restore a device's default parameters
-     * @request POST:/api/devices/{slavePosition}/restore-default-parameters
-     */
-    restoreDefaultParameters: (slavePosition: number, query?: {
-        /**
-         * Which group of defaults to restore — all (0x1011:01), communication (0x1011:02), application (0x1011:03), or manufacturer (0x1011:04).
-         * @default "all"
-         * @example "all"
-         */
-        group?: "all" | "communication" | "application" | "manufacturer";
-        /**
-         * Maximum number of extra confirmation polls after the first.
-         * @min 0
-         * @default 10
-         * @example 5
-         */
-        retries?: number;
-        /**
-         * Delay between confirmation polls, in milliseconds.
-         * @min 0
-         * @default 500
-         * @example 500
-         */
-        interval?: number;
-    }, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<void, void>>;
     /**
      * @description Performs a CoE SDO upload — reads the value of object `index:subindex` from the device at `slavePosition` and returns the raw bytes as a JSON array. Both `index` and `subindex` accept decimal or hexadecimal notation; prefix with `0x` for hex (e.g. `0x6064` or `24676` for object 0x6064).
      *
@@ -829,6 +791,16 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
          */
         error: string;
     }>>;
+    /**
+     * @description Lists what the device holds — firmware images, the ESI, logs, configuration and any high resolution data recording — with the size it reports for each. **Vendor-specific despite reading like a filesystem listing.** EtherCAT defines no directory service, so SOMANET firmware serves its own as a pseudo-file (`fs-getlist`) read over FoE. A device that is not a SOMANET drive is refused rather than probed. `byteCount` is absent when the device reported a name without a size, which is a formatting quirk of one entry rather than a reason to hide the file.
+     *
+     * @name ListDeviceFiles
+     * @summary List the files stored on a device
+     * @request GET:/api/devices/{slavePosition}/files
+     */
+    listDeviceFiles: (slavePosition: number, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<{
+        files: DeviceFile[];
+    }, void>>;
     /**
      * @description Sends an FoE read request for `filename` to the device at `slavePosition` and returns the raw file bytes.  FoE is available in Boot, Pre-Op, Safe-Op, and Op states (device-dependent); the caller is responsible for ensuring the device is in a suitable state before calling.  The call blocks until the full file has been received or a per-packet timeout of 700 ms is exceeded.
      *
@@ -899,6 +871,20 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      * @request POST:/api/sii/parse
      */
     parseSii: (data: File, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<SlaveInformationInterface, void>>;
+    /**
+     * @description Breaks a firmware package filename into the five fields the SOMANET naming convention defines (Hardware description specification §3.4.2) — `package_<hardware>_<fullFirmwareDescriptor>_<software>_v<version>.zip` — and, where the descriptor is the numeric `<id>-<version>[-<key>[-<fieldbus>]]` kind, decodes it further. The specification allows a descriptor that is not (its own example `Branded-Drive-Elite` carries `MyProduct-v25-key3-ecat`), so those four fields are omitted rather than guessed. Bus-independent, like `/api/sii/parse` and `/api/esi/parse`, but a `GET` with a query because there is no file to upload — only a short string. This is the same decoder firmware installation uses to decide whether a package can be cached, so what it reports is what that will do.
+     *
+     * @name GetFirmwarePackageName
+     * @summary Decode a SOMANET firmware package filename
+     * @request GET:/api/firmware-package-name
+     */
+    getFirmwarePackageName: (query: {
+        /**
+         * The package filename, with no directory part.
+         * @example "package_SOMANET-Circulo-7_8500-04-2332_motion-drive_v5.6.10.zip"
+         */
+        filename: string;
+    }, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<FirmwarePackageName, void>>;
     /**
      * @description Decodes a vendor's ESI XML supplied in the request body. No device is involved — the Tools page uses this to inspect an ESI with no hardware present, which is the only way to see object descriptions, enum option labels, engineering units and min/max bounds: the CoE SDO-Information service reports none of them. The response carries the vendor, every module, and **every device with its own assembled `entries` table** — one row per addressable `(index, subindex)`, merged from the device's own dictionary plus the dictionaries of the modules its slots reference, with each row recording in `source` where it came from. Object-level annotation (an object's description and raw properties) is attached to **subindex 0 only** — that row *is* the object — rather than repeated onto every subindex. A RECORD member still carries its own description on its own row; an ARRAY element carries none, because the ESI describes an array once rather than per element. To read an object's text for any subindex, look at subindex 0 of the same index. Where a slot offers mutually exclusive module variants the merge necessarily collides; it is resolved last-wins and reported in that device's `warnings`. Pass `modules` to model one concrete configuration instead.
      *

package/dist/generated/Api.js

@@ -470,7 +470,7 @@ export class Api extends HttpClient {
         ...params,
     });
     /**
-     * @description Starts the named procedure and returns as soon as the run is under way — this does **not** wait for it to finish. Poll `GET` on the same path for its outcome, or `DELETE` to cancel it. The request body carries the procedure's parameters; which fields it accepts (and whether it needs any at all) is per procedure, so consult the descriptor from `GET /api/devices/{slavePosition}/procedures`. A procedure that takes no parameters may be started with no body. Only one procedure may run on a device at a time; a second start is refused with 409 while the first is in flight. Most procedures require an active mailbox, so the device must be in PRE-OP, SAFE-OP or OP. A run the drive answers with an error is not a failure of *this* request — it is reported in the snapshot as a failed run.
+     * @description Starts the named procedure and returns as soon as the run is under way — this does **not** wait for it to finish. Poll `GET` on the same path for its outcome, or `DELETE` to cancel it. The request body carries the procedure's parameters, and each descriptor from `GET /api/devices/{slavePosition}/procedures` reports its own in `parameters` — name, type, bounds, default, and whether it is required — which is enough to build a form for any procedure without hard-coding one per name. A procedure that takes no parameters may be started with no body. Only one procedure may run on a device at a time; a second start is refused with 409 while the first is in flight. Most procedures require an active mailbox, so the device must be in PRE-OP, SAFE-OP or OP. A run the drive answers with an error is not a failure of *this* request — it is reported in the snapshot as a failed run.
      *
      * @name StartProcedure
      * @summary Start a procedure on a device
@@ -522,6 +522,20 @@ export class Api extends HttpClient {
         format: "json",
         ...params,
     });
+    /**
+     * @description Reads the files the `hrd-streaming` procedure recorded, concatenates them in order and decodes them into samples. Run that procedure first; this endpoint only reads what is already on the drive. **`data` is required and must match what was recorded.** Nothing on the drive says which signal its files hold, so the wrong selection reinterprets the same bytes as a different layout and returns plausible nonsense. The procedure's `configure-stream` step reports the selection it used for exactly this reason. Samples travel positionally — `columns` names the fields of each row, once, the way a monitoring topic ships its parameter order once — because a full recording is up to ten thousand rows. `trailingBytes` is what was left over past the last whole sample: the drive allocates its files in fixed-size blocks, so a recording that does not fill the last block ends in padding rather than data. Answers **JSON or CSV**, chosen by the `Accept` header. CSV is the same numbers in the same column order, one header row then one row per sample — a file to open in a spreadsheet rather than JSON to read, which for ten thousand rows is usually what is wanted. Values are decoded, not raw: `velocityRpm` is converted out of the file's Q15 fixed point (exactly — multiply by 32768 to recover the stored integer), while `torquePermil` and the encoder's `raw` word are the file's own values. Blocks for the transfer, which is up to five 8 KB FoE reads plus the listing.
+     *
+     * @name ReadHrdRecording
+     * @summary Read back a drive's high resolution data recording
+     * @request GET:/api/devices/{slavePosition}/hrd
+     */
+    readHrdRecording = (slavePosition, query, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/hrd`,
+        method: "GET",
+        query: query,
+        format: "json",
+        ...params,
+    });
     /**
      * @description Writes "disengaged" to the brake state object (0x2004:07) and waits the drive's pull time (0x2004:03) plus `settle` before answering, because the firmware blocks motion — and motion-related OS commands — until the pull time expires. Answers with the brake state read back. **The release only actually happens while the drive is in OP ENABLED.** In any other state the write merely energises the brake output (phase D). Note also that entering OP ENABLED releases the brake automatically in normal operation but **not** in diagnostics mode, where the master owns the brake — which is why a diagnostics procedure has to call this. **On a pin brake this moves the shaft**: the controller raises current progressively until the load has lifted off the pin by the minimum displacement (0x2004:08), reversing direction if it reaches the current ceiling (0x2004:09, a percentage of rated current) first. Check `releaseMovesShaft` on `GET .../brake`. Brake release is open-loop — nothing confirms the brake let go — so the wait is the only margin there is. A brake whose release strategy is `manualOutputVoltage` is left alone and the returned state says so; that is not an error. **A released brake stays released**: nothing re-engages it for you, so on a vertical or loaded axis engage it again when you are done.
      *
@@ -550,32 +564,6 @@ export class Api extends HttpClient {
         format: "json",
         ...params,
     });
-    /**
-     * @description Commands the device to persist its current parameters (the generic CANopen "store parameters" object 0x1010:01) and waits for confirmation. The server writes the ASCII "save" signature, waits a fixed settle (~1 s) for the drive to begin the flash write, then polls 0x1010:01 until it reads back 1 ("save completed"). Because a store in progress can leave the mailbox briefly unresponsive, a poll that does not yet confirm — a value mismatch or a transient read error alike — is retried up to `retries` more times, `interval` apart. The call blocks until the store is confirmed or the retry budget is exhausted (up to a few seconds); the device's mailbox must be active (PRE-OP/SAFE-OP/OP).
-     *
-     * @name StoreParameters
-     * @summary Store a device's parameters to non-volatile memory
-     * @request POST:/api/devices/{slavePosition}/store-parameters
-     */
-    storeParameters = (slavePosition, query, params = {}) => this.request({
-        path: `/api/devices/${slavePosition}/store-parameters`,
-        method: "POST",
-        query: query,
-        ...params,
-    });
-    /**
-     * @description Commands the device to restore its default parameters (the generic CANopen "restore default parameters" object 0x1011) for the selected `group`, and waits for confirmation. The server writes the ASCII "load" signature to the matching 0x1011 sub-entry, waits a fixed settle (~1 s) for the device to begin, then polls that sub-entry until it reads back 1 ("restore completed"), retrying a poll that does not yet confirm — a value mismatch or a transient read error alike — up to `retries` more times, `interval` apart. The call blocks until the restore is confirmed or the retry budget is exhausted (up to a few seconds); the device's mailbox must be active (PRE-OP/SAFE-OP/OP). **Destructive:** this overwrites the selected group's parameter values in the device's volatile memory with the device's defaults, replacing the current live values (not the persisted store). Which values it touches, and whether it takes effect immediately or after the next reset, is device-specific.
-     *
-     * @name RestoreDefaultParameters
-     * @summary Restore a device's default parameters
-     * @request POST:/api/devices/{slavePosition}/restore-default-parameters
-     */
-    restoreDefaultParameters = (slavePosition, query, params = {}) => this.request({
-        path: `/api/devices/${slavePosition}/restore-default-parameters`,
-        method: "POST",
-        query: query,
-        ...params,
-    });
     /**
      * @description Performs a CoE SDO upload — reads the value of object `index:subindex` from the device at `slavePosition` and returns the raw bytes as a JSON array. Both `index` and `subindex` accept decimal or hexadecimal notation; prefix with `0x` for hex (e.g. `0x6064` or `24676` for object 0x6064).
      *
@@ -604,6 +592,19 @@ export class Api extends HttpClient {
         format: "json",
         ...params,
     });
+    /**
+     * @description Lists what the device holds — firmware images, the ESI, logs, configuration and any high resolution data recording — with the size it reports for each. **Vendor-specific despite reading like a filesystem listing.** EtherCAT defines no directory service, so SOMANET firmware serves its own as a pseudo-file (`fs-getlist`) read over FoE. A device that is not a SOMANET drive is refused rather than probed. `byteCount` is absent when the device reported a name without a size, which is a formatting quirk of one entry rather than a reason to hide the file.
+     *
+     * @name ListDeviceFiles
+     * @summary List the files stored on a device
+     * @request GET:/api/devices/{slavePosition}/files
+     */
+    listDeviceFiles = (slavePosition, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/files`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
     /**
      * @description Sends an FoE read request for `filename` to the device at `slavePosition` and returns the raw file bytes.  FoE is available in Boot, Pre-Op, Safe-Op, and Op states (device-dependent); the caller is responsible for ensuring the device is in a suitable state before calling.  The call blocks until the full file has been received or a per-packet timeout of 700 ms is exceeded.
      *
@@ -671,6 +672,20 @@ export class Api extends HttpClient {
         format: "json",
         ...params,
     });
+    /**
+     * @description Breaks a firmware package filename into the five fields the SOMANET naming convention defines (Hardware description specification §3.4.2) — `package_<hardware>_<fullFirmwareDescriptor>_<software>_v<version>.zip` — and, where the descriptor is the numeric `<id>-<version>[-<key>[-<fieldbus>]]` kind, decodes it further. The specification allows a descriptor that is not (its own example `Branded-Drive-Elite` carries `MyProduct-v25-key3-ecat`), so those four fields are omitted rather than guessed. Bus-independent, like `/api/sii/parse` and `/api/esi/parse`, but a `GET` with a query because there is no file to upload — only a short string. This is the same decoder firmware installation uses to decide whether a package can be cached, so what it reports is what that will do.
+     *
+     * @name GetFirmwarePackageName
+     * @summary Decode a SOMANET firmware package filename
+     * @request GET:/api/firmware-package-name
+     */
+    getFirmwarePackageName = (query, params = {}) => this.request({
+        path: `/api/firmware-package-name`,
+        method: "GET",
+        query: query,
+        format: "json",
+        ...params,
+    });
     /**
      * @description Decodes a vendor's ESI XML supplied in the request body. No device is involved — the Tools page uses this to inspect an ESI with no hardware present, which is the only way to see object descriptions, enum option labels, engineering units and min/max bounds: the CoE SDO-Information service reports none of them. The response carries the vendor, every module, and **every device with its own assembled `entries` table** — one row per addressable `(index, subindex)`, merged from the device's own dictionary plus the dictionaries of the modules its slots reference, with each row recording in `source` where it came from. Object-level annotation (an object's description and raw properties) is attached to **subindex 0 only** — that row *is* the object — rather than repeated onto every subindex. A RECORD member still carries its own description on its own row; an ARRAY element carries none, because the ESI describes an array once rather than per element. To read an object's text for any subindex, look at subindex 0 of the same index. Where a slot offers mutually exclusive module variants the merge necessarily collides; it is resolved last-wins and reported in that device's `warnings`. Pass `modules` to model one concrete configuration instead.
      *

package/dist/generated/data-contracts.d.ts

@@ -390,6 +390,54 @@ export interface ProcedureSnapshot {
     /** Why the run failed when no step captured it — a failure belonging to no step, such as the device not being the kind the procedure needs. Absent otherwise. */
     error?: string;
 }
+/** One file stored on a device, as its file list reports it. */
+export interface DeviceFile {
+    /**
+     * Filename as FoE addresses it.
+     * @example "hr_data0.bin"
+     */
+    name: string;
+    /**
+     * Size the device reported. Absent when it reported the name without one — the size is what the listing claims, not what a read returned.
+     * @example 8032
+     */
+    byteCount?: number;
+}
+/** One high resolution data recording, read back from a drive's files and decoded. */
+export interface HrdRecording {
+    /**
+     * Which layout the files were decoded as — echoes the request.
+     * @example "encoder-raw"
+     */
+    data: "encoder-raw" | "system-identification";
+    /** The files it was read from, in order. A recording that came back shorter than expected can be told from one that was never made by what is listed here. */
+    files: DeviceFile[];
+    /**
+     * Total bytes read across those files.
+     * @example 20000
+     */
+    byteCount: number;
+    /**
+     * Bytes past the last whole sample. The drive allocates its files in fixed-size blocks, so this is the last block's padding rather than data that failed to decode.
+     * @example 0
+     */
+    trailingBytes: number;
+    /**
+     * How many samples were decoded.
+     * @example 5000
+     */
+    sampleCount: number;
+    /**
+     * What each value of a row is, in order. For `encoder-raw`: `raw` (the 32-bit word the encoder reported), `masterCount` (its low 14 bits) and `noniusCount` (the next 14) — the raw word is kept because the firmware specification describes only bits 0-27 and says nothing about the top four. For `system-identification`: `velocityRpm` (converted out of the file's Q15 fixed point) and `torquePermil` (per mille of rated torque).
+     * @example ["raw","masterCount","noniusCount"]
+     */
+    columns: string[];
+    /**
+     * One row per sample, positional in the order `columns` gives — a full recording is up to ten thousand rows, so the names travel once beside them rather than on every row.
+     * @example [[4661,4661,0],[4662,4662,0]]
+     */
+    samples: number[][];
+}
 /** A drive's brake configuration and current state — the parts of object 0x2004 that decide what commanding the brake will actually do. Returned by every brake endpoint, so the outcome of a release or engage arrives in the same shape as a plain read. */
 export interface BrakeState {
     /**
@@ -454,12 +502,122 @@ export interface ProcedureDescriptor {
      * @example false
      */
     requiresEnabled: boolean;
+    /** What the request body may carry, in the order a client should present it. Empty for a procedure that takes none, which is most of them — a procedure's timings are properties of the command it issues rather than a caller's choice. */
+    parameters: ProcedureParameter[];
     /**
      * The ordered step ids the procedure reports against — bare ids, because a template's per-step status is always idle and says nothing. Live status for the same ids is in the snapshot's `steps`.
      * @example ["command"]
      */
     steps: string[];
 }
+/** One choice of an `enum` parameter. */
+export interface ParameterOption {
+    /**
+     * What the request body carries when this option is chosen.
+     * @example 1
+     */
+    value: any;
+    /**
+     * What the user picks.
+     * @example "Encoder 1"
+     */
+    title: string;
+}
+/** One named parameter a procedure accepts — enough to render a field for it and to know what to put in. Descriptive rather than authoritative: the server validates every request whatever a client sends, and this is what lets a client build a sensible form and catch a mistake before the request goes out. The three type-specific fields are absent where they do not apply. */
+export interface ProcedureParameter {
+    /**
+     * The key in the request body.
+     * @example "registerAddress"
+     */
+    name: string;
+    /**
+     * Short label.
+     * @example "Register address"
+     */
+    title: string;
+    /** What it does and what a sensible value is. */
+    description: string;
+    /**
+     * Which kind of control to render. `file` carries a whole file as a base64 string, so a client renders a file picker and encodes what it reads; `stringArray` is an editable list of free-text values.
+     * @example "integer"
+     */
+    type: "integer" | "boolean" | "enum" | "byteArray" | "string" | "stringArray" | "file";
+    /**
+     * Whether a request must carry it — true exactly when there is no `defaultValue`. Reported rather than left to be derived, so a client need not know the rule.
+     * @example true
+     */
+    required: boolean;
+    /**
+     * What an omitting request gets. Absent when the parameter is required.
+     * @example 1
+     */
+    defaultValue?: any;
+    /**
+     * `integer` only: smallest accepted value.
+     * @example 0
+     */
+    minValue?: number;
+    /**
+     * `integer` only: largest accepted value.
+     * @example 255
+     */
+    maxValue?: number;
+    /**
+     * `byteArray` only: the exact number of bytes.
+     * @example 8
+     */
+    length?: number;
+    /** `enum` only: the values that may be chosen. */
+    options?: ParameterOption[];
+}
+/** A SOMANET firmware package filename broken into its fields. The four decoded-descriptor properties are absent — not null — when the full firmware descriptor is not the numeric kind, which the naming specification explicitly allows. */
+export interface FirmwarePackageName {
+    /**
+     * The format description; always `package` for a firmware bundle.
+     * @example "package"
+     */
+    description: string;
+    /**
+     * Human-readable hardware name.
+     * @example "SOMANET-Circulo-7"
+     */
+    hardwareName: string;
+    /**
+     * The full firmware descriptor, verbatim.
+     * @example "8500-04-2332"
+     */
+    firmwareId: string;
+    /**
+     * Software name.
+     * @example "motion-drive"
+     */
+    firmwareName: string;
+    /**
+     * Software version, including the leading `v`.
+     * @example "v5.6.10"
+     */
+    firmwareVersion: string;
+    /**
+     * Product id from the descriptor.
+     * @example 8500
+     */
+    productId?: number;
+    /**
+     * Product version from the descriptor.
+     * @example 4
+     */
+    productVersion?: number;
+    /**
+     * Firmware encryption key id from the descriptor.
+     * @example 2332
+     */
+    keyId?: number;
+    /**
+     * Fieldbus protocol from the descriptor, decoded as hexadecimal. 1 is EtherCAT.
+     * @example 1
+     */
+    fieldbusProtocol?: number;
+}
 /** One procedure paired with how its last run on this device went — an entry of `GET /api/devices/{slavePosition}/procedures`. The pairing is what lets a page render in a single request instead of one per procedure. */
 export interface ProcedureListing {
     /** What a procedure *is*, independent of any run — everything needed to render a control for it. The text is served rather than held per client, because the house rule that every action carries a description and its caveats means it has to exist somewhere, and duplicating it in each client is how it goes stale. */
@@ -467,7 +625,7 @@ export interface ProcedureListing {
     /** The complete state of a procedure on one device — an accumulating snapshot rather than an event, which is what makes polling lossless. */
     snapshot: ProcedureSnapshot;
 }
-/** A procedure's parameters. Which fields apply is per procedure — consult its descriptor — so this schema is open, and a procedure that takes none may be started with no body at all. The properties below are those of `os-command`, where `command` is required. */
+/** A procedure's parameters. Which fields apply is per procedure, and each descriptor reports its own in `parameters` — so this schema is open, and a procedure that takes none may be started with no body at all. The properties below are the union of every procedure's, each naming the procedure it belongs to. */
 export interface ProcedureRequest {
     /**
      * `os-command` only, and required for it: the eight request bytes. Byte 0 is the OS command ID; bytes 1-7 are that command's parameters.
@@ -485,12 +643,84 @@ export interface ProcedureRequest {
      */
     timeoutMs?: number;
     /**
-     * How often the server reads the drive's response object while waiting.
+     * `os-command` only: how often the server reads the drive's response object while waiting.
      * @min 1
      * @max 1000
      * @default 10
      */
     pollIntervalMs?: number;
+    /**
+     * `encoder-register-communication` and `ic-mu-calibration-mode`: which of the drive's encoders to address. Encoder 1 is whatever 0x2110 configures and encoder 2 whatever 0x2112 does, so the ordinal picks a configured slot rather than a kind of encoder.
+     * @default 1
+     * @example 1
+     */
+    encoder?: 1 | 2;
+    /**
+     * `encoder-register-communication` only: false reads the register, true writes `value` into it. Either way the drive reports what the register holds afterwards.
+     * @default false
+     */
+    write?: boolean;
+    /**
+     * `encoder-register-communication` only, and required for it: the register to access. The map belongs to the encoder chip rather than to the drive's firmware.
+     * @min 0
+     * @max 255
+     * @example 117
+     */
+    registerAddress?: number;
+    /**
+     * `encoder-register-communication` only: the byte to write into the register. Ignored when reading.
+     * @min 0
+     * @max 255
+     * @default 0
+     * @example 7
+     */
+    value?: number;
+    /**
+     * `hrd-streaming` only, and required for it: which signal to record. Also decides how the recording decodes when it is read back from `/api/devices/{slavePosition}/hrd`.
+     * @example "encoder-raw"
+     */
+    data?: "encoder-raw" | "system-identification";
+    /**
+     * `hrd-streaming` only, and required for it: how long to record. One sample is written every millisecond into at most five 8032-byte files, so the real ceiling depends on the sample size — 10000 ms for `encoder-raw`, but only 6000 ms for `system-identification`. The drive applies both limits; the narrower one is checked here too, so an over-long request is rejected before a run starts rather than failing on its first step.
+     * @min 1
+     * @max 10000
+     * @example 5000
+     */
+    durationMs?: number;
+    /**
+     * `ic-mu-calibration-mode` only, and required for it: how the BiSS service should clock the encoder. `standard` is normal operation; `configuration` keeps the encoder clocked but uses only the register-communication bits, so position stops updating and no CRC fault is raised; `raw` clocks an encoder already configured for raw output and averages that data into 0x2704. There is no default — the mode is the instruction.
+     * @example "configuration"
+     */
+    mode?: "configuration" | "raw" | "standard";
+    /**
+     * `restore-default-parameters` only: which group of defaults to restore — all (0x1011:01), communication (0x1011:02), application (0x1011:03), or manufacturer (0x1011:04).
+     * @default "all"
+     * @example "all"
+     */
+    group?: "all" | "communication" | "application" | "manufacturer";
+    /** `firmware-installation`: the .zip firmware package, base64-encoded into this JSON string. One of this or a `packageFilename` naming an already-cached package must be present; this wins when both are given. To avoid base64 entirely, `PUT` the raw bytes to `/api/user-cache/firmwares/<name>.zip` first and then send only `packageFilename` — the firmware cache is that directory. (Deliberately not `format: byte`: that is the correct OpenAPI spelling for base64, but generators map it to a binary type — `Blob` in TypeScript — which is not what goes on the wire here and would serialise to `{}`.) */
+    packageContent?: string;
+    /**
+     * `firmware-installation`: the package's filename. Optional — it names the package for caching and identifies a cached one to re-install without uploading it again. A name outside the SOMANET convention still installs, it is just not cached.
+     * @example "package_SOMANET-Circulo-7_8500-04-2332_motion-drive_v5.6.10.zip"
+     */
+    packageFilename?: string;
+    /**
+     * `firmware-installation`: entries inside the package that are not written to the device. An explicit list replaces the defaults wholesale rather than adding to them, so `[]` means "write everything the package holds". Any entry can be named, including the SII and the firmware binaries.
+     * @default ["SOMANET_CiA_402.xml.zip","stack_image.svg.zip"]
+     */
+    skipFiles?: string[];
+    /**
+     * `firmware-installation`: keep a copy of the package on the server so it can be re-installed without uploading it again. Only possible when a filename is given and it follows the SOMANET package naming convention.
+     * @default true
+     */
+    cachePackage?: boolean;
+    /**
+     * `firmware-installation`: where the device is left, as an AL state number — the same ETG.1000.6 encoding `POST /api/devices/state` takes and `alState` reports, so a client holds one way to name a state rather than two. `2` (PRE-OP) is the default and the confirmation that the install worked: the bootloader hands over to the newly written firmware on that transition, so reaching PRE-OP means the new firmware booted. No power cycle is needed for the firmware (an SII written from the package does need one — the ESC reads its EEPROM at reset). Choose `3` (BOOT) when no application will be present, after erasing one or between two installs, since a PRE-OP transition then has nothing to hand over to and the drive answers AL status `0x0014`, "No valid firmware". `4` and `8` climb through PRE-OP and re-map the whole bus on the way, briefly pausing every other device. The state the device was in beforehand is not restored.
+     * @default 2
+     * @example 2
+     */
+    finalState?: 1 | 2 | 3 | 4 | 8;
     [key: string]: any;
 }
 export interface OutputStageResult {

package/dist/index.d.ts

@@ -7,6 +7,5 @@ export * from './client.js';
 export * from './lan.js';
 export * from './hex.js';
 export * from './sdo.js';
-export * from './somanet.js';
 export * from './mmpd.js';
 export * from './wire-time.js';

package/dist/index.js

@@ -14,6 +14,5 @@ export * from './client.js';
 export * from './lan.js';
 export * from './hex.js';
 export * from './sdo.js';
-export * from './somanet.js';
 export * from './mmpd.js';
 export * from './wire-time.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synapticon/motion-master-client",
-  "version": "6.0.0-alpha.64",
+  "version": "6.0.0-alpha.66",
   "description": "Isomorphic TypeScript client for Motion Master: the generated HTTP API client, the WebSocket connection, and helpers.",
   "license": "MIT",
   "repository": {

package/dist/somanet.d.ts

@@ -1,5 +0,0 @@
-export interface SomanetFile {
-    name: string;
-    size: number | null;
-}
-export declare function parseSomanetFileList(text: string): SomanetFile[];

package/dist/somanet.js

@@ -1,15 +0,0 @@
-// Helpers for SOMANET (Synapticon) drive specifics.
-// Parse the body of a SOMANET `fs-getlist` FoE read. Each entry is one line in
-// the form `<filename>, size: <bytes>`; size is null when a line doesn't match.
-export function parseSomanetFileList(text) {
-    return text
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .filter(Boolean)
-        .map(line => {
-        const match = line.match(/^(.*?),\s*size:\s*(\d+)\s*$/);
-        if (match)
-            return { name: match[1].trim(), size: Number(match[2]) };
-        return { name: line, size: null };
-    });
-}