@synapticon/motion-master-client 6.0.0-alpha.61 → 6.0.0-alpha.63

package/dist/generated/Api.d.ts

@@ -1,4 +1,4 @@
-import { AlStatusCode, Cia402Status, DcSyncStatus, DeviceDiagnostics, DeviceParameter, EscRegister, FoeErrorCode, GameLoopHealth, MailboxErrorCode, Monitoring, ObjectDataTypeInfo, OutputStageResult, ParameterCacheEntry, PdoMapping, PdoMappingRequest, ProcessDataWatchdog, ProcessImageObject, SdoAbortCode, SlaveConfig, SlaveInformationInterface } from "./data-contracts.js";
+import { AlStatusCode, Cia402Status, DcSyncStatus, DeviceDiagnostics, DeviceParameter, EscRegister, EsiParseResult, FoeErrorCode, GameLoopHealth, MailboxErrorCode, Monitoring, ObjectDataTypeInfo, OutputStageResult, ParameterCacheEntry, PdoMapping, PdoMappingRequest, 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> {
     /**
@@ -827,6 +827,17 @@ 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 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.
+     *
+     * @name ParseEsi
+     * @summary Parse an EtherCAT Slave Information (ESI) file
+     * @request POST:/api/esi/parse
+     */
+    parseEsi: (data: string, query?: {
+        /** Comma-separated `ModuleIdent` values (hexadecimal or decimal) restricting the merge, applied to every device by intersection with the idents that device's slots actually reference. Omit to merge every module each device references. */
+        modules?: string;
+    }, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<EsiParseResult, void>>;
     /**
      * @description Reads live link-quality and watchdog diagnostics from each slave's EtherCAT Slave Controller (DL Status 0x0110, error-counter block 0x0300–0x0313, watchdog block 0x0440–0x0443) via FPRD. Counters are 8-bit, saturate at 255, and are cleared only by a power cycle or explicit write — poll this endpoint and watch for a rising delta rather than an absolute value. The per-port counters localise a degrading link to a specific cable/connector; the watchdog counters distinguish a slave that stopped receiving process data from a master-side problem. Omit `positions` to query all discovered devices. Returns 500 for transports without an ESC (e.g. SPoE).
      *
@@ -1120,7 +1131,7 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
         error: string;
     }>>;
     /**
-     * @description Serialises the process-data recorder's current span — every cycle from the oldest still in the ring up to the newest at the instant of the call — to a `.mmpd` file and returns its path. Each cycle's full raw input and output images, sequence, and epoch-nanosecond timestamp are written, with the process image (per-device identity and PDO object layout, including object names and data types where the object dictionary has been enumerated) embedded as a header, so the file decodes fully offline with no running Motion Master and no live bus. Works in any state: while devices are exchanging (SAFE-OP/OP) it captures tail→head at that moment and ignores cycles recorded afterwards; after the bus has left the exchange states it uses the most recent retained image layout. The file is written under the configured `recorder.dumpDir` (default: a `motion-master` subdirectory of the OS temporary directory), created if absent. Motion Master binds 127.0.0.1, so the file is on the caller's own machine — only the path is returned (there is no download, list, or delete endpoint).
+     * @description Serialises the process-data recorder's current span — every cycle from the oldest still in the ring up to the newest at the instant of the call — to a `.mmpd` file and returns its path. Each cycle's full raw input and output images, sequence, and epoch-nanosecond timestamp are written, with the process image (per-device identity and PDO object layout, including object names and data types where the object dictionary has been enumerated) embedded as a header, so the file decodes fully offline with no running Motion Master and no live bus. Works in any state: while devices are exchanging (SAFE-OP/OP) it captures tail→head at that moment and ignores cycles recorded afterwards; after the bus has left the exchange states it uses the most recent retained image layout. The file is written under the configured `recorder.dumpDir`, created if absent; by default that is a `dumps` subdirectory of the user-cache root, so the written file is also reachable through the `/api/user-cache` endpoints — list it, download it, or delete it there. Only the path is returned here. (Setting an explicit `recorder.dumpDir` outside the cache root opts out of that; the file is then only reachable from a shell on the server.)
      *
      * @name DumpProcessData
      * @summary Dump the recorder ring to a binary .mmpd file
@@ -1221,17 +1232,17 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
     /**
      * @description Returns one entry per cached parameter-definition file on disk, keyed by device identity (vendor, product, revision). The cache stores only the object-dictionary *definitions* (not live values), so a scan of previously-seen hardware can skip the slow SDO enumeration. Independent of the bus — works whether or not a driver is initialised.
      *
-     * @name ListParameterCaches
+     * @name ListParameterCacheEntries
      * @summary List on-disk parameter caches
-     * @request GET:/api/parameter-caches
+     * @request GET:/api/parameter-cache
      */
-    listParameterCaches: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<ParameterCacheEntry[], any>>;
+    listParameterCacheEntries: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<ParameterCacheEntry[], any>>;
     /**
      * @description Returns the raw JSON cache file for the given id, verbatim, so it can be saved or inspected offline.
      *
      * @name GetParameterCache
      * @summary Download a parameter-cache file
-     * @request GET:/api/parameter-caches/{id}
+     * @request GET:/api/parameter-cache/{id}
      */
     getParameterCache: (id: string, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<object, void>>;
     /**
@@ -1239,7 +1250,50 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      *
      * @name DeleteParameterCache
      * @summary Delete a parameter-cache file
-     * @request DELETE:/api/parameter-caches/{id}
+     * @request DELETE:/api/parameter-cache/{id}
      */
     deleteParameterCache: (id: string, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<void, void>>;
+    /**
+     * @description Returns every file in Motion Master's per-user cache directory, flattened: one entry per file with its full path relative to the cache root, whatever the nesting. Directories have no entries of their own. Independent of the bus — works whether or not a driver is initialised. The cache is a plain file store for data that should outlive a restart. The store itself neither validates nor interprets an upload — `PUT` accepts any bytes at any valid path, and putting a file here does not, on its own, make Motion Master do anything with it; the client chooses the paths. That is separate from whether a *feature* reads a given file, and several do: `parameters/` (the on-disk object-dictionary cache) and `dumps/` (`.mmpd` recorder dumps) are written and consumed by those features, with more to follow. Their files appear in this listing alongside everything else, so a client must not assume every entry was uploaded through this API, nor that deleting one is inconsequential.
+     *
+     * @name ListUserCacheFiles
+     * @summary List the files in the user cache
+     * @request GET:/api/user-cache
+     */
+    listUserCacheFiles: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<UserCacheListing, void>>;
+    /**
+     * @description Returns the file verbatim, always as `application/octet-stream` and always with `Content-Disposition: attachment`, `X-Content-Type-Options: nosniff` and a `default-src 'none'; sandbox` CSP. The bytes are whatever a user uploaded, served from the API's own origin, so a browser must never *render* them — a rendered upload would be stored XSS against the origin that controls the drives, which CORS cannot help with. No extension is trusted to name a content type, and the attachment carries no `filename` (the path is user-controlled and must not reach a response header). Clients read the bytes and name the saved file themselves.
+     *
+     * @name GetUserCacheFile
+     * @summary Download a user-cache file
+     * @request GET:/api/user-cache/{path}
+     */
+    getUserCacheFile: (path: string, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<Blob, void>>;
+    /**
+     * @description Writes the request body to the given path, creating parent directories as needed and replacing any existing file. The write is atomic — a concurrent reader sees either the old contents or the new one, never a partial file. The body is taken as raw bytes whatever its content type.
+     *
+     * @name PutUserCacheFile
+     * @summary Upload a user-cache file
+     * @request PUT:/api/user-cache/{path}
+     */
+    putUserCacheFile: (path: string, data: File, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<{
+        /**
+         * The path written, relative to the cache root.
+         * @example "configs/machine-a.json"
+         */
+        path: string;
+        /**
+         * Bytes written.
+         * @example 20480
+         */
+        size: number;
+    }, void>>;
+    /**
+     * @description Removes a file, or a directory and everything under it. Directories left empty between the removed path and the cache root are pruned, so no husks remain.
+     *
+     * @name DeleteUserCacheFile
+     * @summary Delete a user-cache file or directory
+     * @request DELETE:/api/user-cache/{path}
+     */
+    deleteUserCacheFile: (path: string, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<void, void>>;
 }

package/dist/generated/Api.js

@@ -577,6 +577,21 @@ export class Api extends HttpClient {
         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.
+     *
+     * @name ParseEsi
+     * @summary Parse an EtherCAT Slave Information (ESI) file
+     * @request POST:/api/esi/parse
+     */
+    parseEsi = (data, query, params = {}) => this.request({
+        path: `/api/esi/parse`,
+        method: "POST",
+        query: query,
+        body: data,
+        format: "json",
+        ...params,
+    });
     /**
      * @description Reads live link-quality and watchdog diagnostics from each slave's EtherCAT Slave Controller (DL Status 0x0110, error-counter block 0x0300–0x0313, watchdog block 0x0440–0x0443) via FPRD. Counters are 8-bit, saturate at 255, and are cleared only by a power cycle or explicit write — poll this endpoint and watch for a rising delta rather than an absolute value. The per-port counters localise a degrading link to a specific cable/connector; the watchdog counters distinguish a slave that stopped receiving process data from a master-side problem. Omit `positions` to query all discovered devices. Returns 500 for transports without an ESC (e.g. SPoE).
      *
@@ -701,7 +716,7 @@ export class Api extends HttpClient {
         ...params,
     });
     /**
-     * @description Serialises the process-data recorder's current span — every cycle from the oldest still in the ring up to the newest at the instant of the call — to a `.mmpd` file and returns its path. Each cycle's full raw input and output images, sequence, and epoch-nanosecond timestamp are written, with the process image (per-device identity and PDO object layout, including object names and data types where the object dictionary has been enumerated) embedded as a header, so the file decodes fully offline with no running Motion Master and no live bus. Works in any state: while devices are exchanging (SAFE-OP/OP) it captures tail→head at that moment and ignores cycles recorded afterwards; after the bus has left the exchange states it uses the most recent retained image layout. The file is written under the configured `recorder.dumpDir` (default: a `motion-master` subdirectory of the OS temporary directory), created if absent. Motion Master binds 127.0.0.1, so the file is on the caller's own machine — only the path is returned (there is no download, list, or delete endpoint).
+     * @description Serialises the process-data recorder's current span — every cycle from the oldest still in the ring up to the newest at the instant of the call — to a `.mmpd` file and returns its path. Each cycle's full raw input and output images, sequence, and epoch-nanosecond timestamp are written, with the process image (per-device identity and PDO object layout, including object names and data types where the object dictionary has been enumerated) embedded as a header, so the file decodes fully offline with no running Motion Master and no live bus. Works in any state: while devices are exchanging (SAFE-OP/OP) it captures tail→head at that moment and ignores cycles recorded afterwards; after the bus has left the exchange states it uses the most recent retained image layout. The file is written under the configured `recorder.dumpDir`, created if absent; by default that is a `dumps` subdirectory of the user-cache root, so the written file is also reachable through the `/api/user-cache` endpoints — list it, download it, or delete it there. Only the path is returned here. (Setting an explicit `recorder.dumpDir` outside the cache root opts out of that; the file is then only reachable from a shell on the server.)
      *
      * @name DumpProcessData
      * @summary Dump the recorder ring to a binary .mmpd file
@@ -797,12 +812,12 @@ export class Api extends HttpClient {
     /**
      * @description Returns one entry per cached parameter-definition file on disk, keyed by device identity (vendor, product, revision). The cache stores only the object-dictionary *definitions* (not live values), so a scan of previously-seen hardware can skip the slow SDO enumeration. Independent of the bus — works whether or not a driver is initialised.
      *
-     * @name ListParameterCaches
+     * @name ListParameterCacheEntries
      * @summary List on-disk parameter caches
-     * @request GET:/api/parameter-caches
+     * @request GET:/api/parameter-cache
      */
-    listParameterCaches = (params = {}) => this.request({
-        path: `/api/parameter-caches`,
+    listParameterCacheEntries = (params = {}) => this.request({
+        path: `/api/parameter-cache`,
         method: "GET",
         format: "json",
         ...params,
@@ -812,10 +827,10 @@ export class Api extends HttpClient {
      *
      * @name GetParameterCache
      * @summary Download a parameter-cache file
-     * @request GET:/api/parameter-caches/{id}
+     * @request GET:/api/parameter-cache/{id}
      */
     getParameterCache = (id, params = {}) => this.request({
-        path: `/api/parameter-caches/${id}`,
+        path: `/api/parameter-cache/${id}`,
         method: "GET",
         format: "json",
         ...params,
@@ -825,10 +840,61 @@ export class Api extends HttpClient {
      *
      * @name DeleteParameterCache
      * @summary Delete a parameter-cache file
-     * @request DELETE:/api/parameter-caches/{id}
+     * @request DELETE:/api/parameter-cache/{id}
      */
     deleteParameterCache = (id, params = {}) => this.request({
-        path: `/api/parameter-caches/${id}`,
+        path: `/api/parameter-cache/${id}`,
+        method: "DELETE",
+        ...params,
+    });
+    /**
+     * @description Returns every file in Motion Master's per-user cache directory, flattened: one entry per file with its full path relative to the cache root, whatever the nesting. Directories have no entries of their own. Independent of the bus — works whether or not a driver is initialised. The cache is a plain file store for data that should outlive a restart. The store itself neither validates nor interprets an upload — `PUT` accepts any bytes at any valid path, and putting a file here does not, on its own, make Motion Master do anything with it; the client chooses the paths. That is separate from whether a *feature* reads a given file, and several do: `parameters/` (the on-disk object-dictionary cache) and `dumps/` (`.mmpd` recorder dumps) are written and consumed by those features, with more to follow. Their files appear in this listing alongside everything else, so a client must not assume every entry was uploaded through this API, nor that deleting one is inconsequential.
+     *
+     * @name ListUserCacheFiles
+     * @summary List the files in the user cache
+     * @request GET:/api/user-cache
+     */
+    listUserCacheFiles = (params = {}) => this.request({
+        path: `/api/user-cache`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the file verbatim, always as `application/octet-stream` and always with `Content-Disposition: attachment`, `X-Content-Type-Options: nosniff` and a `default-src 'none'; sandbox` CSP. The bytes are whatever a user uploaded, served from the API's own origin, so a browser must never *render* them — a rendered upload would be stored XSS against the origin that controls the drives, which CORS cannot help with. No extension is trusted to name a content type, and the attachment carries no `filename` (the path is user-controlled and must not reach a response header). Clients read the bytes and name the saved file themselves.
+     *
+     * @name GetUserCacheFile
+     * @summary Download a user-cache file
+     * @request GET:/api/user-cache/{path}
+     */
+    getUserCacheFile = (path, params = {}) => this.request({
+        path: `/api/user-cache/${path}`,
+        method: "GET",
+        ...params,
+    });
+    /**
+     * @description Writes the request body to the given path, creating parent directories as needed and replacing any existing file. The write is atomic — a concurrent reader sees either the old contents or the new one, never a partial file. The body is taken as raw bytes whatever its content type.
+     *
+     * @name PutUserCacheFile
+     * @summary Upload a user-cache file
+     * @request PUT:/api/user-cache/{path}
+     */
+    putUserCacheFile = (path, data, params = {}) => this.request({
+        path: `/api/user-cache/${path}`,
+        method: "PUT",
+        body: data,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Removes a file, or a directory and everything under it. Directories left empty between the removed path and the cache root are pruned, so no husks remain.
+     *
+     * @name DeleteUserCacheFile
+     * @summary Delete a user-cache file or directory
+     * @request DELETE:/api/user-cache/{path}
+     */
+    deleteUserCacheFile = (path, params = {}) => this.request({
+        path: `/api/user-cache/${path}`,
         method: "DELETE",
         ...params,
     });

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

@@ -89,6 +89,16 @@ export interface GameLoopHealth {
      * @example false
      */
     memLocked: boolean;
+    /**
+     * Core the real-time thread was configured to pin to (gameLoop.cpuAffinity), or -1 when unpinned. Pointing this at an isolcpus core is what gives the RT thread a core to itself; only that thread is pinned, so the HTTP, WebSocket and monitoring threads stay on the remaining cores.
+     * @example -1
+     */
+    cpuAffinity: number;
+    /**
+     * Whether the pin took. Always false when cpuAffinity is -1 (nothing was asked for); false while cpuAffinity is >= 0 means the request failed and the thread is running unpinned.
+     * @example false
+     */
+    cpuPinned: boolean;
     /**
      * Server wall-clock timestamp (epoch microseconds) when sampled
      * @format int64
@@ -96,6 +106,33 @@ export interface GameLoopHealth {
      */
     timestampUs: number;
 }
+/** The user cache's location on disk plus every file it holds. */
+export interface UserCacheListing {
+    /**
+     * Absolute path of the cache directory on the server's filesystem. Platform-dependent (and overridable via the `userCache.directory` config key), so it is reported rather than assumed — show it to the user so they can find the files themselves.
+     * @example "/home/user/.cache/motion-master"
+     */
+    root: string;
+    files: UserCacheFile[];
+}
+/** One file in the user cache. */
+export interface UserCacheFile {
+    /**
+     * Path relative to the cache root, always with `/` separators. Use it verbatim in the download/upload/delete endpoints.
+     * @example "configs/machine-a.json"
+     */
+    path: string;
+    /**
+     * File size in bytes.
+     * @example 20480
+     */
+    size: number;
+    /**
+     * Last-write time, in milliseconds since the Unix epoch.
+     * @example 1783968687738
+     */
+    modifiedMs: number;
+}
 /** Summary of one on-disk parameter-cache file (its identity, size, and count). */
 export interface ParameterCacheEntry {
     /**
@@ -929,3 +966,129 @@ export interface SiiPdo {
         flags?: number;
     }[];
 }
+/** One addressable `(index, subindex)` of a device's object dictionary, assembled from the ESI. `defaultData`/`minData`/`maxData` are **raw little-endian bytes** as uppercase hexBinary, the same spelling the ESI itself uses — the first byte is the least significant, so `92010200` is `0x00020192`. Decode them with `dataType`; a byte-wise comparison of `minData` against `maxData` is wrong when `isSigned`. */
+export interface EsiEntry {
+    /** Effective CoE index */
+    index: number;
+    subindex: number;
+    /** Index as written in the source dictionary; omitted when unrelocated */
+    rawIndex?: number;
+    /** The parent object's name — identical across all its subindices */
+    objectName: string;
+    /** This subindex's own name */
+    entryName: string;
+    /** The ESI's display-name override, else `entryName` */
+    displayName: string;
+    objectCode: "VAR" | "ARRAY" | "RECORD";
+    /** The CoE object code (ETG.1000.6 §5) — 7, 8 or 9 */
+    objectCodeValue?: number;
+    /** Highest subindex; omitted for a VAR */
+    numberOfEntries?: number;
+    /**
+     * ESI/IEC 61131-3 type name, e.g. `UDINT`, `STRING(50)`
+     * @example "UDINT"
+     */
+    dataTypeName: string;
+    /**
+     * ETG.1020 code, matching `DeviceParameter.dataType`; 0 if unresolved
+     * @example 7
+     */
+    dataType: number;
+    isSigned: boolean;
+    bitSize: number;
+    /** Offset within the object's complete-access image */
+    bitOffset: number;
+    /** Uppercase hexBinary */
+    defaultData?: string;
+    minData?: string;
+    maxData?: string;
+    /** Packed ETG.1004 notation value */
+    unit?: number;
+    /** @example "mV" */
+    unitSymbol?: string;
+    access: {
+        mode: "ro" | "rw" | "wo";
+        readRestrictions?: "PreOP" | "PreOP_SafeOP" | "PreOP_OP" | "SafeOP" | "SafeOP_OP" | "OP";
+        writeRestrictions?: "PreOP" | "PreOP_SafeOP" | "PreOP_OP" | "SafeOP" | "SafeOP_OP" | "OP";
+    };
+    /** Mandatory, optional or conditional */
+    category: "m" | "o" | "c";
+    /** Empty when not mappable; `t` TxPDO, `r` RxPDO */
+    pdoMapping: "" | "t" | "r" | "tr";
+    safetyMapping?: "si" | "so" | "sio" | "sp";
+    sdoAccess: "SubIndexAccess" | "CompleteAccess";
+    backup: boolean;
+    setting: boolean;
+    /** SoE IDN */
+    attribute?: number;
+    /** ETG.1000.6 ObjAccess bitfield synthesised from the flags — bits 0-2 read in PreOP/SafeOP/OP, 3-5 write, 6 RxPDO-mappable, 7 TxPDO-mappable, 8 backup, 9 setting. Matches `DeviceParameter.access`. */
+    objAccess: number;
+    /** This row's description (HTML), decoded from `properties`. On subindex 0 it is the object's; on a RECORD member it is that member's; an ARRAY element has none. */
+    description?: string;
+    /** Enum labels, from `<EnumInfo>` and/or an `options` property */
+    options?: {
+        label: string;
+        value: number;
+    }[];
+    /** Raw `<Property>` annotations as written, for whatever this row describes. This is the ESI's generic extension mechanism; `description` and `options` above are conveniences decoded from the two conventional names, so a vendor using other names still has its data here. **Subindex 0 carries the object's own annotation** (stored once, not repeated onto every subindex); other rows carry only what that entry itself declares. */
+    properties?: EsiProperties;
+    /** Which dictionary this entry came from. The module's *name* is not repeated here — resolve `moduleIdent` against the top-level `modules` list. */
+    source: {
+        kind: "device" | "module";
+        moduleIdent?: number;
+        /** Zero-based slot number */
+        slot?: number;
+        /** Slot offset applied to `rawIndex` */
+        indexOffset?: number;
+    };
+}
+/** Raw `<Property>` annotations as written, for whatever this row describes. This is the ESI's generic extension mechanism; `description` and `options` above are conveniences decoded from the two conventional names, so a vendor using other names still has its data here. **Subindex 0 carries the object's own annotation** (stored once, not repeated onto every subindex); other rows carry only what that entry itself declares. */
+export type EsiProperties = {
+    name: string;
+    value: string;
+}[];
+export interface EsiDeviceSummary {
+    /** Zero-based position in the file */
+    ordinal: number;
+    /** @example "SOMANET Node" */
+    type: string;
+    name: string;
+    productCode?: number;
+    revisionNo?: number;
+    /** @example 402 */
+    profileNo?: number;
+    groupType: string;
+    /** Objects in the device's own dictionary, before any module merge */
+    objectCount: number;
+    rxPdoCount?: number;
+    txPdoCount?: number;
+    /** Every `ModuleIdent` the device's slots reference, in slot order */
+    moduleIdents: number[];
+    /** The parsed `<Slots>` block */
+    slots?: object;
+    /** This device's flat, slot-merged object dictionary */
+    entries?: EsiEntry[];
+    /** Problems found while assembling *this device* — a value whose byte length disagrees with its declared width, an unresolvable type, a module collision. Distinct from the top-level `warnings`, which are about the document; a different `modules` selection would produce a different list here. */
+    warnings?: string[];
+}
+/** A parsed ESI. Every device carries its own assembled `entries` table. */
+export interface EsiParseResult {
+    /** The `EtherCATInfo/@Version` attribute */
+    version?: string;
+    vendor: {
+        /** @example 8914 */
+        id: number;
+        name: string;
+        url?: string;
+    };
+    devices: EsiDeviceSummary[];
+    modules: {
+        moduleIdent: number;
+        /** @example "CiA402 Dictionary" */
+        type: string;
+        name: string;
+        objectCount?: number;
+    }[];
+    /** Recoverable problems in the document itself — a skipped malformed object, an unparsable value. A file with warnings still parses. Per-device assembly problems are reported on the device instead. */
+    warnings?: string[];
+}

package/package.json

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