@mokouliszt/mel-device 0.3.1 → 0.4.0

package/README.ja.md

@@ -2,9 +2,9 @@
 
 [English](README.md)
 
-三菱電機 MELSEC / MXコントローラ および MELFAロボットコントローラのデバイス表記を、シリーズとCPU／コントローラ型名を含めて検証する、依存ライブラリなしのnpmパッケージです。
+三菱電機 MELSEC / MXコントローラ、MELFAロボットコントローラ、およびFRインバータのシーケンス機能のデバイス表記を、シリーズとCPU／コントローラ／インバータ型名を含めて検証する、依存ライブラリなしのnpmパッケージです。
 
-対応シリーズは iQ-R、iQ-F、MX-R、MX-F、CR800-R/D/Qです。ES Modules と CommonJS の両方から利用できます。
+対応シリーズは iQ-R、iQ-F、MX-R、MX-F、CR800-R/D/Q、および FR-A800／A800 Plus／F800／E800 インバータ（シーケンス機能とSLMPデバイステーブルの両方）です。ES Modules と CommonJS の両方から利用できます。
 
 ## インストール
 
@@ -46,7 +46,7 @@ isValidDevice("U3E0\\G524287", {
 
 `analyzeDevice` は、単なる `true` / `false` ではなく、正規化後の型名、解釈したデバイス、失敗理由、参照マニュアルとページ、実機設定への依存有無を返します。入力欄のバリデーションにはこちらを推奨します。
 
-`model`を省略できるのは、`series`に`CR800-R`、`CR800-D`、`CR800-Q`のいずれかを直接指定した場合だけです。その他のシリーズでは従来どおり型名を指定してください。
+`model`を省略できるのは、`series`に`CR800-R`、`CR800-D`、`CR800-Q`、`FR-A800`、`FR-A800-E`、`FR-F800`、`FR-E800`のような単一機種のショートハンドを直接指定した場合です。`iQ-R`、`iQ-F`、`MX-R`、`MX-F`、`CR800`、`FR800`では従来どおり型名を指定してください。
 
 ## 判定モード
 
@@ -59,7 +59,7 @@ PLCのM/D等はCPUパラメータで点数を変更できるため、型名だ
 | `configured` | 実機プロジェクトの厳密判定 | `configuredPoints` に渡した実際の点数で判定。可変デバイスの点数が未指定なら `MISSING_CONFIGURATION`。 |
 | `syntax` | エディタ入力途中・構文チェック | 型名が対応するデバイス文法のみを確認し、点数範囲を無視。 |
 
-CR800-R/D/Qのデバイス範囲はマニュアル上固定されているため、`default`、`maximum`、`configured`はいずれも同じ固定範囲を使用します。
+CR800-R/D/QおよびFRインバータのデバイス範囲はマニュアル上固定されているため、これらのシリーズでは`configuredPoints`を参照しません。ただしインバータでは、`maximum`が後述のSERIAL依存のT/C 32点拡張と未割付のST点数を許可します。インバータが受け付ける点数指定は`configuredPoints.ST`のみです。
 
 ```js
 isValidDevice("D99", {
@@ -182,6 +182,123 @@ CR800-Qの表6-16にある`U3En\G512-G1023`は、表6-13の固定範囲`G10000-G
 
 定数（`K100`, `HFF`, 実数・文字列）は「デバイス」ではないため判定対象外です。ラベル、構造体メンバ、SLMPのバイナリデバイスコードも対象外です。
 
+## FRインバータ シーケンス機能
+
+FR-A800／A800 Plus／F800／E800のシーケンス機能はデバイステーブルが1種類に固定されているため、シリーズを`FR800`、インバータのファミリを型名として扱います。単一ファミリのショートハンドを`series`に直接指定した場合は`model`を省略できます。
+
+```js
+isValidDevice("X8F", { series: "FR-A800" }); // true（Xは16進で144点）
+isValidDevice("X90", { series: "FR-A800" }); // false
+
+analyzeDevice("P100", { series: "FR-E800" });
+// valid: true, configurationDependent: true（PデバイスはSERIALの製造年月に依存）
+
+analyzeDevice("P100", { series: "FR-A800" }).code; // "DEVICE_NOT_SUPPORTED"
+```
+
+| デバイス | FR-A800 / FR-A800 Plus / FR-F800 | FR-E800 | 基数 |
+| --- | --- | --- | --- |
+| X、Y | `X0～X8F`、`Y0～Y8F`（各144点） | 同左 | 16進 |
+| M | `M0～M127` | 同左 | 10進 |
+| L | 点数なし（シーケンスパラメータで設定可能だがラッチしない） | 同左 | - |
+| T、C | `0～15`、または下記拡張で`0～31` | `0～15` | 10進 |
+| ST | 初期値0点。割付けにより`0～15`、下記拡張で`0～31`まで | 初期値0点。割付けにより`0～15`まで | 10進 |
+| D | `D0～D255` | 同左 | 10進 |
+| P | 記載なし | `P0～P127`、`P2048～P2175` | 10進 |
+| SM、SD | `0～2047`（機能制限あり） | 同左 | 10進 |
+| N | `N0～N14`（MC/MCRのネスティング） | 同左 | 10進 |
+
+### SERIAL（製造年月）依存機能
+
+マニュアルには、インバータ定格名板のSERIALが示す製造年月によって対応可否が変わるデバイス機能が2つ記載されています。型名だけでは断定できないため、暗黙に許可せず別扱いで返します。
+
+```js
+analyzeDevice("T16", { series: "FR-A800" });
+// valid: false, code: "REQUIRES_SERIAL_SUPPORT", suggestedMode: "maximum"
+
+isValidDevice("T16", { series: "FR-A800", mode: "maximum" });                            // true（設定依存）
+isValidDevice("T16", { series: "FR-A800", frFeatures: { extendedTimerPoints: true } });  // true（確定）
+isValidDevice("T16", { series: "FR-A800", frFeatures: { extendedTimerPoints: false } }); // false
+```
+
+| `frFeatures` | 対象 | 意味 |
+| --- | --- | --- |
+| `extendedTimerPoints` | FR-A800、FR-A800-E、FR-A800-CRN、FR-A800-LC、FR-F800、FR-F800-E | T/ST/Cの32点対応 |
+| `pointerDevice` | FR-E800系 | Pデバイス256点対応 |
+
+マニュアルが対応と記載していない型名に対して`true`を指定した場合は、範囲を黙って広げず`INVALID_FR_FEATURES`を返します。
+
+### 積算タイマは初期値0点
+
+デバイス一覧では積算タイマSTの初期値が0点であり、シーケンスパラメータで割り付けて初めて使用できます。そのためPLCシリーズの点数変更可能デバイスと同じ扱いにしています。
+
+```js
+analyzeDevice("ST0", { series: "FR-A800" });
+// valid: false, code: "REQUIRES_CONFIGURATION", suggestedMode: "maximum"
+
+isValidDevice("ST15", { series: "FR-A800", mode: "maximum" });                                  // true（設定依存）
+isValidDevice("ST15", { series: "FR-A800", mode: "configured", configuredPoints: { ST: 16 } }); // true
+isValidDevice("ST16", { series: "FR-A800", mode: "configured", configuredPoints: { ST: 16 } }); // false
+```
+
+`configuredPoints.ST`の上限は16点、上記の32点拡張対応機種では32点です。
+
+### SLMPデバイステーブル
+
+Ethernet仕様のインバータは、外部のSLMPクライアントに対してシーケンス機能とは別のデバイステーブルを公開しています。`frAccess: "slmp"`を指定するとそちらで判定し、結果にSLMPのデバイスコードとアクセス単位が付きます。
+
+```js
+analyzeDevice("X7F", { series: "FR-A800-E", frAccess: "slmp" });
+// valid: true, deviceCode: "H9C", deviceUnit: "bit"
+
+isValidDevice("X80", { series: "FR-A800-E", frAccess: "slmp" }); // false（SLMPはH7Fまで）
+isValidDevice("X80", { series: "FR-A800-E" });                   // true （シーケンス機能はH8Fまで）
+```
+
+| デバイス | コード | 単位 | 範囲 |
+| --- | --- | --- | --- |
+| SM | `H91` | ビット | `0～2047` |
+| SD | `HA9` | ワード | `0～2047` |
+| X | `H9C` | ビット | `H0～H7F` |
+| Y | `H9D` | ビット | `H0～H7F` |
+| M | `H90` | ビット | `0～127` |
+| D | `HA8` | ワード | `0～255` |
+| W | `HB4` | ワード | `0～8191`（FR-E800のEthernet仕様品のみ） |
+| `TS` / `TC` / `TN` | `HC1` / `HC0` / `HC2` | ビット / ビット / ワード | `0～15` |
+| `STS` / `STC` / `STN`（`SS` / `SC` / `SN`） | `HC7` / `HC6` / `HC8` | ビット / ビット / ワード | 初期値0点、割付けにより`0～15`まで |
+| `CS` / `CC` / `CN` | `HC4` / `HC3` / `HC5` | ビット / ビット / ワード | `0～15` |
+
+補足:
+
+- SLMPアクセスの記載はEthernet仕様品のみです。それ以外の型名では`MODEL_NOT_SUPPORTED`を返します。
+- SLMPは接点・コイル・現在値を別デバイスとして指定するため、素の`T0`は無効とし、`TS0`／`TC0`／`TN0`を案内します。
+- 積算タイマの各部は、FR-A800-E/F800-Eのマニュアルでは`STS`/`STC`/`STN`、FR-E800のマニュアルでは`SS`/`SC`/`SN`と表記されます。両方を受け付け、選択した型名のマニュアル表記を警告で示します。
+- 両マニュアルのSLMP表はT/CとSTを16点で頭打ちにしているため、`extendedTimerPoints`では広がりません。
+- リンクレジスタ`W`はパラメータとモニタデータに対応し、PLCシリーズと異なり10進です。`parseDevice("W999", { series: "FR-E800-E" })`のアドレスは999になります。
+- P、N、L、桁指定はSLMPデバイステーブルに含まれません。
+
+### 桁指定と入力デバイス
+
+桁指定はビットデバイスX、Y、Mのみに記載があります。本パッケージは、指定した点数がデバイス範囲内に収まるかも判定します。
+
+```js
+isValidDevice("K4X80", { series: "FR-A800" });            // true（X80～X8F）
+analyzeDevice("K4X8C", { series: "FR-A800" }).code;       // "DIGIT_RANGE_OVERFLOW"
+analyzeDevice("K4D0", { series: "FR-A800" }).code;        // "DIGIT_MODIFIER_NOT_SUPPORTED"
+```
+
+入力デバイスXは毎スキャン外部端子やネットワークからリフレッシュされるため、プログラムから駆動できません。`analyzeDevice`はCR800と同じフィールドでこれを返します。
+
+```js
+analyzeDevice("X0", { series: "FR-A800", operation: "write" });
+// valid: true, access: "read-only", operationAllowed: false
+// warnings: インバータ運転状態制御にはSM1200/SM1255、SD1148/SD1149を使用する旨
+```
+
+X/Yの`30H`以降はCC-Linkリモート入出力（`30H～3FH`）とEthernetインバータ間リンク入出力（`40H～8FH`）の領域であるため、領域名を含む警告とともに`configurationDependent: true`を返します。
+
+ビット指定、間接指定、インデックス修飾、ローカルデバイス、ユニットアクセス、および`TS`/`TC`/`TN`形式の接点・コイル・現在値表記は、シーケンス機能のマニュアルに記載がないため保守的に無効とします。
+
 ## API
 
 ### `isValidDevice(value, options): boolean`
@@ -219,6 +336,7 @@ CR800-Qの表6-16にある`U3En\G512-G1023`は、表6-13の固定範囲`G10000-G
 - MX-R: MXR300-16/-32/-64、MXR500-128/-256
 - MX-F: MXF100系のマニュアル対象10機種（`MXF100` をファミリ別名として受付）
 - MELFA CR800: CR800-R、CR800-D、CR800-Q
+- FRインバータ（`FR800`）: FR-A800、FR-A800-E、FR-A800-P、FR-A800-CRN、FR-A800-LC、FR-A800-Plus、FR-F800、FR-F800-E、FR-E800、FR-E800-E、FR-E800-SCE、FR-E800-NC、FR-E806
 
 ## 資料
 

package/README.md

@@ -2,9 +2,9 @@
 
 [日本語](README.ja.md)
 
-A dependency-free npm package for validating Mitsubishi Electric MELSEC/MX controller and MELFA robot controller device notation against a specified series and CPU/controller model.
+A dependency-free npm package for validating Mitsubishi Electric MELSEC/MX controller, MELFA robot controller and FR inverter sequence-function device notation against a specified series and CPU/controller/inverter model.
 
-Supported series are iQ-R, iQ-F, MX-R, MX-F, and CR800-R/D/Q. The package supports both ES Modules and CommonJS.
+Supported series are iQ-R, iQ-F, MX-R, MX-F, CR800-R/D/Q, and the FR-A800/A800 Plus/F800/E800 inverters, covering both their sequence function and their SLMP device table. The package supports both ES Modules and CommonJS.
 
 ## Installation
 
@@ -46,7 +46,7 @@ isValidDevice("U3E0\\G524287", {
 
 Instead of returning only `true` or `false`, `analyzeDevice` reports the normalized model, parsed device, reason for failure, referenced manual and page, and whether the result depends on the actual hardware configuration. It is the recommended API for validating user input.
 
-The `model` option may be omitted only when `series` is set directly to `CR800-R`, `CR800-D`, or `CR800-Q`. A model must still be specified for all other series.
+The `model` option may be omitted when `series` is set directly to a single-model shorthand such as `CR800-R`, `CR800-D`, `CR800-Q`, `FR-A800`, `FR-A800-E`, `FR-F800`, or `FR-E800`. A model must still be specified for `iQ-R`, `iQ-F`, `MX-R`, `MX-F`, `CR800`, and `FR800`.
 
 ## Validation modes
 
@@ -59,7 +59,7 @@ The number of available points for PLC devices such as M and D can be changed in
 | `configured` | Exact validation for an actual project | Validates against the actual point counts supplied in `configuredPoints`. Returns `MISSING_CONFIGURATION` if the point count for a configurable device is omitted. |
 | `syntax` | In-progress editor input and syntax checking | Checks only whether the model supports the device syntax and ignores point-count ranges. |
 
-The device ranges for CR800-R/D/Q are fixed in the manuals, so `default`, `maximum`, and `configured` all use the same fixed ranges.
+The device ranges for CR800-R/D/Q and for the FR inverter sequence function are fixed in the manuals, so `configuredPoints` is ignored for those series. `maximum` still differs for the inverters, because it opts into the SERIAL-dependent 32-point T/C extension and the unallocated ST points described below. `configuredPoints.ST` is the one point count the inverters accept.
 
 ```js
 isValidDevice("D99", {
@@ -182,6 +182,123 @@ Bit specifications, digit specifications, indirect specifications, index modific
 
 Constants (`K100`, `HFF`, real numbers, and strings) are outside the validation scope because they are not devices. Labels, structure members, and SLMP binary device codes are also outside the scope.
 
+## FR inverter sequence function
+
+The FR-A800/A800 Plus/F800/E800 sequence function has one fixed device table, so the series is `FR800` and the inverter family is the model. Single-family shorthands are accepted as `series`, in which case `model` may be omitted.
+
+```js
+isValidDevice("X8F", { series: "FR-A800" }); // true (X is hexadecimal, 144 points)
+isValidDevice("X90", { series: "FR-A800" }); // false
+
+analyzeDevice("P100", { series: "FR-E800" });
+// valid: true, configurationDependent: true (the P device depends on the SERIAL production month)
+
+analyzeDevice("P100", { series: "FR-A800" }).code; // "DEVICE_NOT_SUPPORTED"
+```
+
+| Device | FR-A800 / FR-A800 Plus / FR-F800 | FR-E800 | Radix |
+| --- | --- | --- | --- |
+| X, Y | `X0-X8F`, `Y0-Y8F` (144 points each) | same | hexadecimal |
+| M | `M0-M127` | same | decimal |
+| L | no points (a latch range can be set but nothing latches) | same | - |
+| T, C | `0-15`, or `0-31` with the extension below | `0-15` | decimal |
+| ST | 0 points by default; allocatable up to `0-15`, or `0-31` with the extension below | 0 points by default; allocatable up to `0-15` | decimal |
+| D | `D0-D255` | same | decimal |
+| P | not listed | `P0-P127`, `P2048-P2175` | decimal |
+| SM, SD | `0-2047` (not every number has a function) | same | decimal |
+| N | `N0-N14` (MC/MCR nesting) | same | decimal |
+
+### SERIAL-dependent features
+
+The manual lists two device features whose availability depends on the inverter production month printed on the SERIAL plate. Because the model name alone cannot decide them, they are reported separately instead of being silently allowed.
+
+```js
+analyzeDevice("T16", { series: "FR-A800" });
+// valid: false, code: "REQUIRES_SERIAL_SUPPORT", suggestedMode: "maximum"
+
+isValidDevice("T16", { series: "FR-A800", mode: "maximum" });                       // true (configurationDependent)
+isValidDevice("T16", { series: "FR-A800", frFeatures: { extendedTimerPoints: true } });  // true (asserted)
+isValidDevice("T16", { series: "FR-A800", frFeatures: { extendedTimerPoints: false } }); // false
+```
+
+| `frFeatures` | Applies to | Meaning |
+| --- | --- | --- |
+| `extendedTimerPoints` | FR-A800, FR-A800-E, FR-A800-CRN, FR-A800-LC, FR-F800, FR-F800-E | 32-point T/ST/C extension |
+| `pointerDevice` | FR-E800 family | 256-point P pointer device |
+
+Setting a feature to `true` for a model the manual does not list returns `INVALID_FR_FEATURES` rather than quietly widening the range.
+
+### The accumulating timer starts with no points
+
+The device list gives the accumulating timer ST a default of 0 points, so it is only usable once the sequence parameters allocate it. It is therefore treated like the configurable devices of the PLC series rather than like a fixed range.
+
+```js
+analyzeDevice("ST0", { series: "FR-A800" });
+// valid: false, code: "REQUIRES_CONFIGURATION", suggestedMode: "maximum"
+
+isValidDevice("ST15", { series: "FR-A800", mode: "maximum" });                                  // true (configurationDependent)
+isValidDevice("ST15", { series: "FR-A800", mode: "configured", configuredPoints: { ST: 16 } }); // true
+isValidDevice("ST16", { series: "FR-A800", mode: "configured", configuredPoints: { ST: 16 } }); // false
+```
+
+The ceiling for `configuredPoints.ST` is 16 points, or 32 on a model that has the extension above.
+
+### SLMP device table
+
+The Ethernet inverters expose a different device table to external SLMP clients. Pass `frAccess: "slmp"` to validate against it; the result then also carries the SLMP device code and access unit.
+
+```js
+analyzeDevice("X7F", { series: "FR-A800-E", frAccess: "slmp" });
+// valid: true, deviceCode: "H9C", deviceUnit: "bit"
+
+isValidDevice("X80", { series: "FR-A800-E", frAccess: "slmp" }); // false (the SLMP table stops at H7F)
+isValidDevice("X80", { series: "FR-A800-E" });                   // true  (the sequence map runs to H8F)
+```
+
+| Device | Code | Unit | Range |
+| --- | --- | --- | --- |
+| SM | `H91` | bit | `0-2047` |
+| SD | `HA9` | word | `0-2047` |
+| X | `H9C` | bit | `H0-H7F` |
+| Y | `H9D` | bit | `H0-H7F` |
+| M | `H90` | bit | `0-127` |
+| D | `HA8` | word | `0-255` |
+| W | `HB4` | word | `0-8191` (FR-E800 Ethernet models only) |
+| `TS` / `TC` / `TN` | `HC1` / `HC0` / `HC2` | bit / bit / word | `0-15` |
+| `STS` / `STC` / `STN` (`SS` / `SC` / `SN`) | `HC7` / `HC6` / `HC8` | bit / bit / word | 0 points by default, allocatable up to `0-15` |
+| `CS` / `CC` / `CN` | `HC4` / `HC3` / `HC5` | bit / bit / word | `0-15` |
+
+Points worth knowing:
+
+- SLMP access is documented for the Ethernet models only. Any other model returns `MODEL_NOT_SUPPORTED`.
+- The SLMP table addresses the contact, coil, and current value separately, so a bare `T0` is rejected with a message naming `TS0`, `TC0`, and `TN0`.
+- The accumulating-timer parts are spelled `STS`/`STC`/`STN` in the FR-A800-E/F800-E manual and `SS`/`SC`/`SN` in the FR-E800 manual. Both spellings are accepted, and a warning names the spelling the selected model's manual uses.
+- Both SLMP tables cap T/C and ST at 16 points, so `extendedTimerPoints` does not widen them.
+- The link register `W` maps to parameters and monitor data and is decimal, not hexadecimal as on the PLC series. `parseDevice("W999", { series: "FR-E800-E" })` gives address 999.
+- P, N, L, and digit designation are not part of the SLMP device table.
+
+### Digit designation and input devices
+
+Digit designation is documented for the bit devices X, Y, and M only, and the package also checks that the designated points fit inside the device range.
+
+```js
+isValidDevice("K4X80", { series: "FR-A800" });            // true (X80-X8F)
+analyzeDevice("K4X8C", { series: "FR-A800" }).code;       // "DIGIT_RANGE_OVERFLOW"
+analyzeDevice("K4D0", { series: "FR-A800" }).code;        // "DIGIT_MODIFIER_NOT_SUPPORTED"
+```
+
+Input device X is refreshed from the terminal or network on every scan, so a program cannot drive it. `analyzeDevice` reports this through the same fields used for CR800:
+
+```js
+analyzeDevice("X0", { series: "FR-A800", operation: "write" });
+// valid: true, access: "read-only", operationAllowed: false
+// warnings: use SM1200/SM1255 and SD1148/SD1149 for inverter operation control
+```
+
+X/Y addresses from `30H` upward belong to the CC-Link remote area (`30H-3FH`) and the Ethernet inverter-to-inverter link area (`40H-8FH`), so they return `configurationDependent: true` with a warning naming the area.
+
+Bit selection, indirect specification, index modification, local devices, module access, and the `TS`/`TC`/`TN` style contact/coil/current notation are not documented for the inverter sequence function and are conservatively rejected.
+
 ## API
 
 ### `isValidDevice(value, options): boolean`
@@ -219,6 +336,7 @@ Returns the list of models covered by the manuals.
 - MX-R: MXR300-16/-32/-64 and MXR500-128/-256
 - MX-F: the 10 models covered by the MXF100-series manual (`MXF100` is accepted as a family alias)
 - MELFA CR800: CR800-R, CR800-D, and CR800-Q
+- FR inverters (`FR800`): FR-A800, FR-A800-E, FR-A800-P, FR-A800-CRN, FR-A800-LC, FR-A800-Plus, FR-F800, FR-F800-E, FR-E800, FR-E800-E, FR-E800-SCE, FR-E800-NC, and FR-E806
 
 ## References
 

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 
-const SERIES = ["iQ-R", "iQ-F", "MX-R", "MX-F", "CR800"];
+const SERIES = ["iQ-R", "iQ-F", "MX-R", "MX-F", "CR800", "FR800"];
 
 const IQ_R_MODELS = [
   "R00CPU", "R01CPU", "R02CPU", "R04CPU", "R04ENCPU", "R08CPU", "R08ENCPU",
@@ -13,13 +13,19 @@ const MX_F_MODELS = [
   "MXF100-Y32N", "MXF100-Y32P", "MXF100-H32N", "MXF100-H32P", "MXF100-Y16R"
 ];
 const CR800_MODELS = ["CR800-R", "CR800-D", "CR800-Q"];
+const FR800_MODELS = [
+  "FR-A800", "FR-A800-E", "FR-A800-P", "FR-A800-CRN", "FR-A800-LC", "FR-A800-Plus",
+  "FR-F800", "FR-F800-E",
+  "FR-E800", "FR-E800-E", "FR-E800-SCE", "FR-E800-NC", "FR-E806"
+];
 
 const MODEL_LISTS = {
   "iQ-R": IQ_R_MODELS,
   "iQ-F": IQ_F_MODELS,
   "MX-R": MX_R_MODELS,
   "MX-F": MX_F_MODELS,
-  CR800: CR800_MODELS
+  CR800: CR800_MODELS,
+  FR800: FR800_MODELS
 };
 
 const BIT_PREFIXES = new Set(["X", "DX", "Y", "DY", "M", "L", "B", "F", "SB", "V", "S", "SM", "FX", "FY"]);
@@ -109,7 +115,8 @@ const SOURCES = {
   "iQ-R": { manual: "SH-082487-J", pages: [65, 408, 409, 410, 435, 436] },
   "MX-R": { manual: "SH-082640-D", pages: [350, 351, 352, 380, 381] },
   "MX-F": { manual: "SH-082633-E", pages: [277, 416, 417, 418] },
-  CR800: { manual: "BFP-A3477-AB", pages: [489, 490, 491, 618, 619, 654, 655, 656, 657] }
+  CR800: { manual: "BFP-A3477-AB", pages: [489, 490, 491, 618, 619, 654, 655, 656, 657] },
+  FR800: { manual: "IB-0600491-Q", pages: [8, 11, 22, 23, 24, 25, 26, 27, 28, 107, 125, 126, 157] }
 };
 
 // CPU buffer memory access devices (U3En\G, U3En\HG).
@@ -166,6 +173,99 @@ const CR800_ALLOCATION_LABELS = {
   ccLinkIef: "CC-Link IE Field"
 };
 
+// Inverter sequence function (FR-A800/A800 Plus/F800/E800).
+// IB-0600491-Q p.107 (3.9.1 device list) fixes every point count; p.8 lists the
+// features whose availability depends on the SERIAL production date; p.22-28
+// give the X/Y device map, p.125-126 the K1-K8 digit designation rules for
+// X/Y/M, and p.157 the N0-N14 master-control nesting range.
+const FR_COMMON_LIMITS = { X: 0x8f, Y: 0x8f, M: 127, D: 255, SM: 2047, SD: 2047, N: 14 };
+const FR_POINTER_RANGES = [[0, 127], [2048, 2175]];
+const FR_DIGIT_PREFIXES = new Set(["X", "Y", "M"]);
+const FR_FEATURE_NAMES = new Set(["extendedTimerPoints", "pointerDevice"]);
+
+// timerPoints: [base, extended]. The 32-point T/ST/C extension is only listed
+// for FR-A800 (excluding FR-A800-P), FR-A800 Plus (FR-A800-CRN/LC) and FR-F800,
+// and only from the January 2021 production month onward (p.8).
+// timerPoints: [base, SERIAL-extended] for T and C. ST always defaults to 0
+// points (p.11 note *8) and is allocated by the sequence parameters up to the
+// same figure. slmp/linkRegister follow the Ethernet manuals; stSpelling is the
+// accumulating-timer spelling each SLMP table uses.
+const FR800_RULES = {
+  "FR-A800": { timerPoints: [16, 32], pointer: false, slmp: false, linkRegister: false, stSpelling: "ST" },
+  "FR-A800-E": { timerPoints: [16, 32], pointer: false, slmp: true, linkRegister: false, stSpelling: "ST" },
+  "FR-A800-P": { timerPoints: [16, 16], pointer: false, slmp: false, linkRegister: false, stSpelling: "ST" },
+  "FR-A800-CRN": { timerPoints: [16, 32], pointer: false, slmp: false, linkRegister: false, stSpelling: "ST" },
+  "FR-A800-LC": { timerPoints: [16, 32], pointer: false, slmp: false, linkRegister: false, stSpelling: "ST" },
+  "FR-A800-Plus": { timerPoints: [16, 16], pointer: false, slmp: false, linkRegister: false, stSpelling: "ST" },
+  "FR-F800": { timerPoints: [16, 32], pointer: false, slmp: false, linkRegister: false, stSpelling: "ST" },
+  "FR-F800-E": { timerPoints: [16, 32], pointer: false, slmp: true, linkRegister: false, stSpelling: "ST" },
+  "FR-E800": { timerPoints: [16, 16], pointer: true, slmp: false, linkRegister: false, stSpelling: "S" },
+  "FR-E800-E": { timerPoints: [16, 16], pointer: true, slmp: true, linkRegister: true, stSpelling: "S" },
+  "FR-E800-SCE": { timerPoints: [16, 16], pointer: true, slmp: true, linkRegister: true, stSpelling: "S" },
+  "FR-E800-NC": { timerPoints: [16, 16], pointer: true, slmp: false, linkRegister: false, stSpelling: "S" },
+  "FR-E806": { timerPoints: [16, 16], pointer: true, slmp: true, linkRegister: true, stSpelling: "S" }
+};
+
+// SLMP device codes and ranges (IB-0600627-D p.37, IB-0600870-S p.132-133).
+// The SLMP tables cap T/C at 16 points and ST at 16 points regardless of the
+// 32-point sequence-function extension, and cut X/Y at H7F rather than H8F.
+const FR_SLMP_DEVICES = {
+  SM: { code: "H91", unit: "bit", max: 2047 },
+  SD: { code: "HA9", unit: "word", max: 2047 },
+  X: { code: "H9C", unit: "bit", max: 0x7f },
+  Y: { code: "H9D", unit: "bit", max: 0x7f },
+  M: { code: "H90", unit: "bit", max: 127 },
+  D: { code: "HA8", unit: "word", max: 255 },
+  W: { code: "HB4", unit: "word", max: 8191, requires: "linkRegister" },
+  TS: { code: "HC1", unit: "bit", max: 15 },
+  TC: { code: "HC0", unit: "bit", max: 15 },
+  TN: { code: "HC2", unit: "word", max: 15 },
+  STS: { code: "HC7", unit: "bit", allocated: true },
+  STC: { code: "HC6", unit: "bit", allocated: true },
+  STN: { code: "HC8", unit: "word", allocated: true },
+  CS: { code: "HC4", unit: "bit", max: 15 },
+  CC: { code: "HC3", unit: "bit", max: 15 },
+  CN: { code: "HC5", unit: "word", max: 15 }
+};
+const FR_SLMP_ST_MAX = 16;
+const FR_SLMP_SPELLING = { STS: "SS", STC: "SC", STN: "SN" };
+
+// The accumulating-timer parts are spelled STS/STC/STN in the FR-A800-E/F800-E
+// manual and SS/SC/SN in the FR-E800 manual; both spellings are accepted.
+const FR_TIMER_ALIAS = {
+  TS: ["T", "contact"], TC: ["T", "coil"], TN: ["T", "current"],
+  STS: ["ST", "contact"], STC: ["ST", "coil"], STN: ["ST", "current"],
+  SS: ["ST", "contact"], SC: ["ST", "coil"], SN: ["ST", "current"],
+  CS: ["C", "contact"], CC: ["C", "coil"], CN: ["C", "current"]
+};
+
+const FR_SERIES_ALIASES = {
+  FR800: null, FR8: null,
+  FRA800: "FR-A800", FRA800E: "FR-A800-E", FRA800P: "FR-A800-P",
+  FRA800CRN: "FR-A800-CRN", FRA800LC: "FR-A800-LC", FRA800PLUS: "FR-A800-Plus",
+  FRF800: "FR-F800", FRF800E: "FR-F800-E",
+  FRE800: "FR-E800", FRE800E: "FR-E800-E", FRE800SCE: "FR-E800-SCE",
+  FRE800NC: "FR-E800-NC", FRE806: "FR-E806"
+};
+
+const FR_MODEL_ALIASES = {
+  A800: "FR-A800", A800E: "FR-A800-E", A800P: "FR-A800-P",
+  A800CRN: "FR-A800-CRN", A800LC: "FR-A800-LC", A800PLUS: "FR-A800-Plus",
+  CRN: "FR-A800-CRN", LC: "FR-A800-LC", PLUS: "FR-A800-Plus",
+  F800: "FR-F800", F800E: "FR-F800-E",
+  E800: "FR-E800", E800E: "FR-E800-E", E800SCE: "FR-E800-SCE",
+  E800NC: "FR-E800-NC", E806: "FR-E806"
+};
+
+// X/Y map areas (p.22-28). Everything from X30/Y30 upward only exists while the
+// matching network is configured, so those addresses stay configuration-dependent.
+const FR_IO_AREAS = [
+  [0x00, 0x1f, "external and built-in option I/O", false],
+  [0x20, 0x2f, "inverter system I/O", false],
+  [0x30, 0x3f, "CC-Link remote I/O", true],
+  [0x40, 0x8f, "Ethernet inverter-to-inverter link I/O", true]
+];
+
 class MelDeviceError extends Error {
   constructor(message, result) {
     super(message);
@@ -175,22 +275,35 @@ class MelDeviceError extends Error {
   }
 }
 
+function compactName(value) {
+  return value.normalize("NFKC").trim().toUpperCase().replace(/[\s_-]/g, "");
+}
+
 function canonicalSeries(value) {
   if (typeof value !== "string") return null;
-  const compact = value.normalize("NFKC").trim().toUpperCase().replace(/[\s_-]/g, "");
+  const compact = compactName(value);
+  if (Object.prototype.hasOwnProperty.call(FR_SERIES_ALIASES, compact)) return "FR800";
   return ({ IQR: "iQ-R", IQF: "iQ-F", MXR: "MX-R", MXF: "MX-F", CR800: "CR800", CR800R: "CR800", CR800D: "CR800", CR800Q: "CR800" })[compact] || null;
 }
 
 function cr800ModelFromSeries(value) {
   if (typeof value !== "string") return null;
-  const compact = value.normalize("NFKC").trim().toUpperCase().replace(/[\s_-]/g, "");
-  return ({ CR800R: "CR800-R", CR800D: "CR800-D", CR800Q: "CR800-Q" })[compact] || null;
+  return ({ CR800R: "CR800-R", CR800D: "CR800-D", CR800Q: "CR800-Q" })[compactName(value)] || null;
+}
+
+function fr800ModelFromSeries(value) {
+  if (typeof value !== "string") return null;
+  return FR_SERIES_ALIASES[compactName(value)] || null;
+}
+
+function modelFromSeries(value) {
+  return cr800ModelFromSeries(value) || fr800ModelFromSeries(value);
 }
 
 function normalizeModel(series, value) {
   const s = canonicalSeries(series);
   if (!s) return null;
-  if (s === "CR800" && value == null) return cr800ModelFromSeries(series);
+  if ((s === "CR800" || s === "FR800") && value == null) return modelFromSeries(series);
   if (typeof value !== "string") return null;
   const model = value.normalize("NFKC").trim().toUpperCase().replace(/\s+/g, "");
   if (s === "iQ-R") {
@@ -210,16 +323,20 @@ function normalizeModel(series, value) {
     return MX_R_MODELS.includes(model) ? model : null;
   }
   if (s === "CR800") {
-    const compact = String(value).normalize("NFKC").trim().toUpperCase().replace(/[\s_-]/g, "");
+    const compact = compactName(String(value));
     return ({ R: "CR800-R", D: "CR800-D", Q: "CR800-Q", CR800R: "CR800-R", CR800D: "CR800-D", CR800Q: "CR800-Q" })[compact] || null;
   }
+  if (s === "FR800") {
+    const compact = compactName(String(value));
+    return FR_SERIES_ALIASES[compact] || FR_MODEL_ALIASES[compact] || null;
+  }
   if (model === "MXF100") return model;
   return MX_F_MODELS.includes(model) ? model : null;
 }
 
 function getSupportedModels(series) {
   const s = canonicalSeries(series);
-  const inferred = cr800ModelFromSeries(series);
+  const inferred = modelFromSeries(series);
   if (inferred) return [inferred];
   return s ? [...MODEL_LISTS[s]] : [];
 }
@@ -246,6 +363,9 @@ function invalid(input, series, model, mode, code, message, extra = {}) {
 }
 
 function radixFor(series, prefix) {
+  // Both inverter manuals print X/Y in hexadecimal and every other device,
+  // including the link register W, in decimal.
+  if (series === "FR800") return prefix === "X" || prefix === "Y" ? 16 : 10;
   const radix = RADIX[prefix];
   if (radix === "series-x") return series === "iQ-F" ? 8 : 16;
   return radix || 10;
@@ -259,13 +379,14 @@ function parseNumber(text, radix) {
 }
 
 function parseDirect(text, series) {
-  const timerPrefixes = Object.keys(TIMER_ALIAS).sort((a, b) => b.length - a.length);
+  const aliases = series === "FR800" ? FR_TIMER_ALIAS : TIMER_ALIAS;
+  const timerPrefixes = Object.keys(aliases).sort((a, b) => b.length - a.length);
   for (const alias of timerPrefixes) {
     if (!text.startsWith(alias)) continue;
     const addressText = text.slice(alias.length);
     const address = parseNumber(addressText, 10);
     if (address !== null) {
-      const [prefix, timerPart] = TIMER_ALIAS[alias];
+      const [prefix, timerPart] = aliases[alias];
       return { kind: "direct", prefix, notationPrefix: alias, address, addressText, radix: 10, timerPart };
     }
   }
@@ -582,6 +703,265 @@ function analyzeCr800(value, parsed, series, model, mode, normalized, operation,
   };
 }
 
+function validateFrFeatures(features, model) {
+  if (features === undefined) return null;
+  if (!features || typeof features !== "object" || Array.isArray(features)) {
+    return "frFeatures must be an object when supplied.";
+  }
+  for (const [name, state] of Object.entries(features)) {
+    if (!FR_FEATURE_NAMES.has(name)) return `Unknown FR feature: ${name}.`;
+    if (typeof state !== "boolean") return `frFeatures.${name} must be boolean.`;
+  }
+  const rule = FR800_RULES[model];
+  if (features.extendedTimerPoints === true && rule.timerPoints[0] === rule.timerPoints[1]) {
+    return `${model} is not listed as supporting the 32-point T/ST/C extension.`;
+  }
+  if (features.pointerDevice === true && !rule.pointer) {
+    return `${model} is not listed as supporting the P pointer device.`;
+  }
+  return null;
+}
+
+function frTimerCeiling(model, mode, features) {
+  const [base, extended] = FR800_RULES[model].timerPoints;
+  const declared = typeof features.extendedTimerPoints === "boolean" ? features.extendedTimerPoints : null;
+  if (declared !== null) return { points: declared ? extended : base, dependent: false };
+  if (mode === "maximum") return { points: extended, dependent: extended !== base };
+  return { points: base, dependent: false, serialExtendedTo: extended !== base ? extended : null };
+}
+
+// Sequence-function ranges (IB-0600491-Q p.107). ST has no points until the
+// sequence parameters allocate them, so it behaves like the other configurable
+// devices in this package rather than like a fixed range.
+function frSequenceRange(prefix, model, mode, options, features) {
+  const rule = FR800_RULES[model];
+  if (prefix === "T" || prefix === "C") {
+    const ceiling = frTimerCeiling(model, mode, features);
+    return {
+      ranges: [[0, ceiling.points - 1]],
+      dependent: ceiling.dependent,
+      serialExtendedTo: ceiling.serialExtendedTo == null ? null : ceiling.serialExtendedTo - 1
+    };
+  }
+  if (prefix === "ST") {
+    const ceiling = frTimerCeiling(model, mode, features);
+    if (mode === "configured") {
+      const points = options.configuredPoints && options.configuredPoints.ST;
+      if (!Number.isInteger(points) || points < 0) return { missingConfiguration: true };
+      if (points > ceiling.points) return { invalidConfiguration: true, ceiling: ceiling.points };
+      return { ranges: [[0, points - 1]], dependent: false };
+    }
+    if (mode === "maximum") return { ranges: [[0, ceiling.points - 1]], dependent: true, allocated: true };
+    return { ranges: [], dependent: false, allocatableTo: ceiling.points - 1 };
+  }
+  if (prefix === "P") {
+    if (!rule.pointer) return null;
+    return { ranges: FR_POINTER_RANGES, dependent: features.pointerDevice !== true };
+  }
+  const limit = FR_COMMON_LIMITS[prefix];
+  if (limit === undefined) return null;
+  return { ranges: [[0, limit]], dependent: false };
+}
+
+// SLMP ranges (IB-0600627-D p.37, IB-0600870-S p.132-133).
+function frSlmpRange(entry, model, mode, options) {
+  if (!entry.allocated) return { ranges: [[0, entry.max]], dependent: false };
+  if (mode === "configured") {
+    const points = options.configuredPoints && options.configuredPoints.ST;
+    if (!Number.isInteger(points) || points < 0) return { missingConfiguration: true };
+    if (points > FR_SLMP_ST_MAX) return { invalidConfiguration: true, ceiling: FR_SLMP_ST_MAX };
+    return { ranges: [[0, points - 1]], dependent: false };
+  }
+  if (mode === "maximum") return { ranges: [[0, FR_SLMP_ST_MAX - 1]], dependent: true, allocated: true };
+  return { ranges: [], dependent: false, allocatableTo: FR_SLMP_ST_MAX - 1 };
+}
+
+function frIoArea(address) {
+  return FR_IO_AREAS.find(([start, end]) => address >= start && address <= end) || null;
+}
+
+function analyzeFr(value, parsed, series, model, mode, normalized, operation, options) {
+  const features = options.frFeatures || {};
+  const access = options.frAccess || "sequence";
+  const rule = FR800_RULES[model];
+  const fail = (code, message, extra = {}) => invalid(value, series, model, mode, code, message, { normalized, parsed, ...extra });
+
+  if (parsed.kind !== "direct") {
+    return fail("DEVICE_NOT_SUPPORTED", `${parsed.kind} device notation is not listed for the inverter.`);
+  }
+  if (parsed.local || parsed.indirect || parsed.bit !== null || parsed.index !== null) {
+    return fail("MODIFIER_NOT_SUPPORTED", "The inverter manuals do not document bit selection, indirect specification, index modification, or local devices.");
+  }
+  if (prefixIsLatchRelay(parsed)) {
+    return fail("DEVICE_NOT_SUPPORTED", "The latch relay L has no points on the inverter; the sequence parameters accept a latch range but nothing is latched.");
+  }
+
+  if (access === "slmp") return analyzeFrSlmp(value, parsed, series, model, mode, normalized, operation, options, rule, fail);
+
+  if (parsed.timerPart) {
+    return fail("DEVICE_NOT_SUPPORTED", `${parsed.notationPrefix} contact/coil/current notation belongs to the SLMP device table, not to the sequence program; use ${parsed.prefix}${parsed.addressText}, or pass frAccess: "slmp".`);
+  }
+  const prefix = parsed.prefix;
+  if (parsed.digit !== null && !FR_DIGIT_PREFIXES.has(prefix)) {
+    return fail("DIGIT_MODIFIER_NOT_SUPPORTED", "K1-K8 digit designation is documented only for the bit devices X, Y, and M.");
+  }
+
+  const range = frSequenceRange(prefix, model, mode, options, features);
+  if (!range) {
+    return fail("DEVICE_NOT_SUPPORTED", `${prefix} is not listed as an inverter sequence function device for ${model}.`);
+  }
+  if (range.missingConfiguration) {
+    return fail("MISSING_CONFIGURATION", "configuredPoints.ST is required in configured mode; the accumulating timer defaults to 0 points.");
+  }
+  if (range.invalidConfiguration) {
+    return fail("INVALID_CONFIGURATION", `configuredPoints.ST exceeds the ${range.ceiling}-point maximum documented for ${model}.`);
+  }
+
+  return frResult(value, parsed, series, model, mode, normalized, operation, range, {
+    label: "inverter sequence function",
+    allocationHint: 'The accumulating timer ST defaults to 0 points; allocate it in the sequence parameters, then use mode "maximum" or configuredPoints.ST.',
+    checkDigit: true,
+    ioAreas: true
+  });
+}
+
+function prefixIsLatchRelay(parsed) {
+  return parsed.prefix === "L" && !parsed.timerPart;
+}
+
+function analyzeFrSlmp(value, parsed, series, model, mode, normalized, operation, options, rule, fail) {
+  if (!rule.slmp) {
+    return fail("MODEL_NOT_SUPPORTED", `SLMP device access is documented for the Ethernet inverters (FR-A800-E, FR-F800-E, FR-E800-E, FR-E800-SCE, FR-E806), not for ${model}.`);
+  }
+  if (parsed.digit !== null) {
+    return fail("DIGIT_MODIFIER_NOT_SUPPORTED", "SLMP addresses a head device and a point count; K1-K8 digit designation is not part of the device specification.");
+  }
+
+  const key = parsed.timerPart ? `${parsed.prefix}${{ contact: "S", coil: "C", current: "N" }[parsed.timerPart]}` : parsed.prefix;
+  const entry = FR_SLMP_DEVICES[key];
+  if (!entry) {
+    const parts = { T: ["TS", "TC", "TN"], ST: rule.stSpelling === "S" ? ["SS", "SC", "SN"] : ["STS", "STC", "STN"], C: ["CS", "CC", "CN"] }[parsed.prefix];
+    const hint = parts
+      ? ` The SLMP table addresses the contact, coil, and current value separately, so use ${parts.map(part => `${part}${parsed.addressText}`).join(", ")}.`
+      : "";
+    return fail("DEVICE_NOT_SUPPORTED", `${parsed.notationPrefix || parsed.prefix} is not listed in the SLMP device table.${hint}`);
+  }
+  if (entry.requires && !rule[entry.requires]) {
+    return fail("DEVICE_NOT_SUPPORTED", `The link register W is only listed in the FR-E800 SLMP device table, not for ${model}.`);
+  }
+
+  const range = frSlmpRange(entry, model, mode, options);
+  if (range.missingConfiguration) {
+    return fail("MISSING_CONFIGURATION", "configuredPoints.ST is required in configured mode; the accumulating timer defaults to 0 points.");
+  }
+  if (range.invalidConfiguration) {
+    return fail("INVALID_CONFIGURATION", `configuredPoints.ST exceeds the ${range.ceiling}-point maximum documented in the SLMP device table.`);
+  }
+
+  const spellingWarning = [];
+  const canonical = FR_SLMP_SPELLING[key];
+  if (canonical) {
+    const expected = rule.stSpelling === "S" ? canonical : key;
+    if ((parsed.notationPrefix || "") !== expected) {
+      spellingWarning.push(`The ${model} manual spells this accumulating-timer device ${expected}${parsed.addressText}; ${parsed.notationPrefix}${parsed.addressText} is accepted as the equivalent from the other inverter manual.`);
+    }
+  }
+  if (parsed.prefix === "SM" && entry.unit === "bit") {
+    spellingWarning.push("For word-unit SLMP access to SM, the head device number must be one listed in the special relay table, otherwise the read or write is not performed correctly.");
+  }
+
+  return frResult(value, parsed, series, model, mode, normalized, operation, range, {
+    label: "SLMP device table",
+    allocationHint: 'The accumulating timer defaults to 0 points; allocate it in the sequence parameters, then use mode "maximum" or configuredPoints.ST.',
+    checkDigit: false,
+    ioAreas: true,
+    deviceCode: entry.code,
+    deviceUnit: entry.unit,
+    extraWarnings: spellingWarning
+  });
+}
+
+function frResult(value, parsed, series, model, mode, normalized, operation, range, context) {
+  const prefix = parsed.prefix;
+  const fail = (code, message, extra = {}) => invalid(value, series, model, mode, code, message, { normalized, parsed, ...extra });
+  const withinRange = address => range.ranges.some(([start, end]) => address >= start && address <= end);
+  const warnings = [...(context.extraWarnings || [])];
+  let configurationDependent = range.dependent;
+
+  if (mode !== "syntax") {
+    if (!withinRange(parsed.address)) {
+      if (range.allocatableTo != null && parsed.address <= range.allocatableTo) {
+        return fail("REQUIRES_CONFIGURATION", `${parsed.notationPrefix || prefix}${parsed.addressText} needs sequence-parameter allocation. ${context.allocationHint}`,
+          { configurationDependent: true, suggestedMode: "maximum" });
+      }
+      if (range.serialExtendedTo != null && parsed.address <= range.serialExtendedTo) {
+        return fail("REQUIRES_SERIAL_SUPPORT",
+          `${prefix}${parsed.addressText} needs the 32-point T/C extension, which ${model} only provides from the January 2021 production month onward. Check the SERIAL plate, then use mode "maximum" or frFeatures.extendedTimerPoints.`,
+          { configurationDependent: true, suggestedMode: "maximum" });
+      }
+      return fail("ADDRESS_OUT_OF_RANGE", `${parsed.notationPrefix || prefix}${parsed.addressText} is outside the ${model} range in the ${context.label}.`);
+    }
+    if (context.checkDigit && parsed.digit !== null) {
+      const last = parsed.address + parsed.digit * 4 - 1;
+      if (!withinRange(last)) {
+        return fail("DIGIT_RANGE_OVERFLOW", `K${parsed.digit}${prefix}${parsed.addressText} covers ${parsed.digit * 4} points and runs past the end of the ${prefix} range.`);
+      }
+    }
+    if (range.dependent && (prefix === "T" || prefix === "C")) {
+      warnings.push("The 32-point T/C extension depends on the SERIAL production month; pass frFeatures.extendedTimerPoints once it is known.");
+    }
+    if (range.allocated) {
+      warnings.push("The accumulating timer is only usable once the sequence parameters allocate its points; pass configuredPoints.ST for an exact result.");
+    }
+    if (range.dependent && prefix === "P") {
+      warnings.push("The 256-point P pointer device depends on the SERIAL production month; pass frFeatures.pointerDevice once it is known.");
+    }
+    if (context.ioAreas && (prefix === "X" || prefix === "Y")) {
+      const area = frIoArea(parsed.address);
+      if (area && area[3]) {
+        configurationDependent = true;
+        warnings.push(`${prefix}${parsed.addressText} belongs to the ${area[2]} area, which only exists while that network is configured.`);
+      }
+    }
+  }
+
+  const readOnly = mode !== "syntax" && prefix === "X";
+  if (readOnly) {
+    warnings.push("Input device X is refreshed from the terminal or network every scan, so turning it on does not drive the corresponding signal. Use SM1200/SM1255 and SD1148/SD1149 for inverter operation control instead.");
+  }
+  const operationAllowed = operation === "write" ? !readOnly : operation === "read" ? true : null;
+
+  const common = {
+    valid: true, input: value, normalized, series, model, mode, operation, code: "VALID",
+    parsed, source: SOURCES[series]
+  };
+  if (context.deviceCode) {
+    common.deviceCode = context.deviceCode;
+    common.deviceUnit = context.deviceUnit;
+  }
+
+  if (mode === "syntax") {
+    return {
+      ...common,
+      message: `Valid ${context.label} device syntax; range and access were not evaluated in syntax mode.`,
+      configurationDependent: false, access: "not-evaluated", operationAllowed: null, warnings: []
+    };
+  }
+
+  return {
+    ...common,
+    message: operation === "write" && readOnly
+      ? "Valid device notation and range, but X is an input image that cannot be driven."
+      : configurationDependent
+        ? `Valid within the ${context.label} range; confirm the inverter SERIAL, sequence parameters, and network configuration.`
+        : `Valid within the ${context.label} range.`,
+    configurationDependent,
+    access: readOnly ? "read-only" : "read-write",
+    operationAllowed,
+    warnings
+  };
+}
+
 function analyzeDevice(value, options = {}) {
   const mode = options.mode || "default";
   const inputMode = options.inputMode || "exact";
@@ -597,7 +977,7 @@ function analyzeDevice(value, options = {}) {
   }
   const series = canonicalSeries(options.series);
   if (!series) return invalid(value, null, null, mode, "UNSUPPORTED_SERIES", `Supported series: ${SERIES.join(", ")}.`);
-  const seriesModel = cr800ModelFromSeries(options.series);
+  const seriesModel = modelFromSeries(options.series);
   const model = normalizeModel(options.series, options.model ?? seriesModel);
   if (!model) return invalid(value, series, null, mode, "UNSUPPORTED_MODEL", `Unsupported ${series} model: ${String(options.model)}.`);
   if (seriesModel && model !== seriesModel) return invalid(value, series, model, mode, "MODEL_SERIES_MISMATCH", `${String(options.series)} conflicts with model ${model}.`);
@@ -605,11 +985,19 @@ function analyzeDevice(value, options = {}) {
     const featureError = validateCr800Features(options.cr800Features);
     if (featureError) return invalid(value, series, model, mode, "INVALID_CR800_FEATURES", featureError);
   }
+  if (series === "FR800") {
+    const featureError = validateFrFeatures(options.frFeatures, model);
+    if (featureError) return invalid(value, series, model, mode, "INVALID_FR_FEATURES", featureError);
+    if (options.frAccess !== undefined && !["sequence", "slmp"].includes(options.frAccess)) {
+      return invalid(value, series, model, mode, "INVALID_FR_ACCESS", "frAccess must be sequence or slmp.");
+    }
+  }
   const parsed = parseDevice(value, { series, inputMode });
   const normalized = inputMode === "friendly" ? normalizeDevice(value) : (typeof value === "string" ? value : null);
   if (!parsed) return invalid(value, series, model, mode, "INVALID_SYNTAX", "The value is not a supported MELSEC/MELFA device notation.", { normalized });
 
   if (series === "CR800") return analyzeCr800(value, parsed, series, model, mode, normalized, operation, options.cr800Features);
+  if (series === "FR800") return analyzeFr(value, parsed, series, model, mode, normalized, operation, options);
 
   if (series === "iQ-F" && ["V", "LT", "LST", "ZR", "RD", "FX", "FY", "FD"].includes(parsed.prefix)) {
     return invalid(value, series, model, mode, "DEVICE_NOT_SUPPORTED", `${parsed.prefix} is not listed as an iQ-F device in the attached manual.`, { normalized, parsed });

package/dist/index.d.ts

@@ -1,8 +1,16 @@
-export type MelSeries = "iQ-R" | "iQ-F" | "MX-R" | "MX-F" | "CR800" | "CR800-R" | "CR800-D" | "CR800-Q";
+export type MelSeries =
+  | "iQ-R" | "iQ-F" | "MX-R" | "MX-F"
+  | "CR800" | "CR800-R" | "CR800-D" | "CR800-Q"
+  | "FR800"
+  | "FR-A800" | "FR-A800-E" | "FR-A800-P" | "FR-A800-CRN" | "FR-A800-LC" | "FR-A800-Plus"
+  | "FR-F800" | "FR-F800-E"
+  | "FR-E800" | "FR-E800-E" | "FR-E800-SCE" | "FR-E800-NC" | "FR-E806";
 export type ValidationMode = "syntax" | "default" | "maximum" | "configured";
 export type InputMode = "exact" | "friendly";
 export type DeviceOperation = "read" | "write" | "either";
 export type DeviceAccess = "read-write" | "read-only" | "configuration-dependent" | "not-evaluated";
+/** "sequence" validates the sequence-program device table, "slmp" the SLMP device table of the Ethernet inverters. */
+export type FrAccess = "sequence" | "slmp";
 
 export interface Cr800Features {
   /** CR800-R/Q sequencer I/O unit direct control (parameter QXYREAD). */
@@ -25,6 +33,22 @@ export interface Cr800Features {
   ccLinkIef?: boolean;
 }
 
+export interface FrFeatures {
+  /**
+   * 32-point T/ST/C extension. Listed only for FR-A800/FR-A800-E (excluding
+   * FR-A800-P), FR-A800 Plus (FR-A800-CRN/LC) and FR-F800/FR-F800-E, from the
+   * January 2021 production month onward. Omit when the SERIAL plate has not
+   * been checked. Ignored for `frAccess: "slmp"`, whose table caps T/C/ST at
+   * 16 points.
+   */
+  extendedTimerPoints?: boolean;
+  /**
+   * 256-point P pointer device. Listed only for FR-E800, from the January 2021
+   * production month onward.
+   */
+  pointerDevice?: boolean;
+}
+
 export interface DeviceOptions {
   series: MelSeries | string;
   model?: string;
@@ -34,6 +58,10 @@ export interface DeviceOptions {
   configuredPoints?: Partial<Record<string, number>>;
   /** Known CR800 feature states. Omitted properties are treated as unknown. */
   cr800Features?: Cr800Features;
+  /** Known inverter feature states. Omitted properties are treated as unknown. */
+  frFeatures?: FrFeatures;
+  /** Which inverter device table to validate against. Defaults to "sequence". */
+  frAccess?: FrAccess;
 }
 
 export interface ParsedDevice {
@@ -73,6 +101,10 @@ export interface DeviceAnalysis {
   operationAllowed?: boolean | null;
   activeAllocations?: string[];
   possibleAllocations?: string[];
+  /** SLMP device code, such as "H9C". Present for `frAccess: "slmp"` results. */
+  deviceCode?: string;
+  /** SLMP access unit for the device code. */
+  deviceUnit?: "bit" | "word";
   warnings?: string[];
   parsed?: ParsedDevice;
   suggestedMode?: ValidationMode;

package/docs/manual-evidence.md

@@ -11,6 +11,9 @@
 | MX-R | MELSEC MXコントローラ MX-Rモデルユーザーズマニュアル | SH-082640-D | 221（性能仕様）、350（デバイス一覧・デフォルト点数）、351-352（点数設定・最大使用範囲）、376-378（ユニット／CPUバッファアクセス指定方法）、380-381（インデックス修飾） |
 | MX-F | MELSEC MXコントローラ MX-Fモデルユーザーズマニュアル | SH-082633-E | 277（性能・デフォルト点数）、416（デバイス一覧）、417-418（点数設定・最大使用範囲）、441-443（ユニット／CPUバッファアクセス指定方法） |
 | CR800 | CR800シリーズコントローラ 機能と操作の詳細解説 | BFP-A3477-AB | 5-489～5-491（CPUバッファ対応）、6-618～6-619（シーケンサリンク）、6-654（対応デバイス一覧）、6-655～6-657（デバイス割付） |
+| FR800 | FR-A800/F800/E800 シーケンス機能プログラミングマニュアル | IB-0600491-Q | 8（SERIAL別対応可否）、11-12（シーケンス機能仕様・注記*8）、22-28（デバイスマップ）、107（デバイス一覧）、125-126（桁指定）、157（ネスティング） |
+| FR800（SLMP） | A800-E/F800-E Ethernet機能説明書 | IB-0600627-D | 37（SLMPデバイスコードと範囲）、38（デバイス番号指定）、94（インバータ間リンクデバイスマップ） |
+| FR800（SLMP） | FR-E800取扱説明書（通信編） | IB-0600870-S | 12（Ethernet対応仕様品）、132-133（SLMPデバイスコードと範囲・リンクレジスタ）、136（デバイス番号指定）、222（インバータ間リンクデバイスマップ） |
 
 ## 基数
 
@@ -18,6 +21,7 @@
 | --- | --- | --- | --- |
 | iQ-F | X, Y | B, SB, W, SW | その他の通常デバイス |
 | iQ-R / MX-R / MX-F | - | X, Y, B, SB, W, SW, FX, FY | その他の通常デバイス |
+| FR800 | - | X, Y | その他の通常デバイス |
 
 この差により、iQ-Fの `X1777` は有効候補ですが `X1780` は構文エラーです。一方、iQ-R/MXのX/Yは16進です。
 
@@ -153,3 +157,96 @@ iQ-F本文69ページではZによる全デバイスのインデックス修飾
 - 6.2.2／表6-4: `U3En\G10000-G10511`をロボットCPU No.nの領域として使用
 
 このため`U3En\G512-G1023`は有効範囲へ追加しません。該当入力には`MANUAL_RANGE_CONFLICT`を返します。IQMEMの意図された読み出し側アドレスと考えられる`U3En\G10512-G11023`は固定範囲としては有効ですが、表記不整合が解消できないため、IQMEM有効時でもR属性を断定せず`configuration-dependent`とします。これはマニュアル間の矛盾を隠して推測値を確定しないための意図的な保守性です。
+
+## FRインバータ シーケンス機能（FR-A800/A800 Plus/F800/E800）
+
+本文107ページ「3.9.1 デバイス一覧」が全デバイスの点数と使用範囲を確定しています。点数はシーケンスパラメータで変更できないため、`configuredPoints`は参照しません。
+
+| 記号 | FR-A800 / FR-A800 Plus / FR-F800 | FR-E800 | 基数 |
+| --- | --- | --- | --- |
+| X | `X0-X8F`（144点） | 同左 | 16進 |
+| Y | `Y0-Y8F`（144点） | 同左 | 16進 |
+| M | `M0-M127`（128点） | 同左 | 10進 |
+| L | ―（シーケンスパラメータ設定可能だがラッチしない） | 同左 | ― |
+| T | `T0-T15` / `T0-T31` | `T0-T15` | 10進 |
+| ST | 初期値0点（割付けにより `ST0-ST15` / `ST0-ST31`） | 初期値0点（割付けにより `ST0-ST15`） | 10進 |
+| C | `C0-C15` / `C0-C31` | `C0-C15` | 10進 |
+| D | `D0-D255`（256点） | 同左 | 10進 |
+| P | 記載なし | `P0-P127`、`P2048-P2175`（256点、すべて共通ポインタ） | 10進 |
+| SM | `SM0-SM2047`（機能制限あり） | 同左 | 10進 |
+| SD | `SD0-SD2047`（機能制限あり） | 同左 | 10進 |
+
+X/Yの144点は、本文22-28ページのデバイスマップが `X0-X1F`（外部入出力・内蔵オプション）、`X20-X2F`（システム入出力）、`X30-X3F`（CC-Linkリモート入出力）、`X40-X8F`（Ethernetインバータ間リンク、マスタ局は5スレーブ分）と連続的に割り付けていることと一致します。Y側も同一構成です。`X30`以降は該当ネットワークの構成時のみ存在するため、成功時も設定依存として警告を付けます。
+
+ネスティング（N）はデバイス一覧には含まれませんが、本文157ページに「入れ子は15個（N0～14）まで」と明記されているため、`N0-N14`のみ有効としています。
+
+### SERIAL（製造年月）依存
+
+本文8ページ「1.1.1 SERIAL（製造番号）の確認」の表は、次の3機能を2021年1月以降の製造品のみ対応としています。
+
+| 機能 | FR-A800（FR-A800-Pは除く）／FR-A800 Plus（FR-A800-CRN/LC） | FR-A800 Plus（FR-A800-CRN/LC以外） | FR-F800 | FR-E800 |
+| --- | :-: | :-: | :-: | :-: |
+| プログラム言語（ST）対応 | − | − | − | ○ |
+| T/ST/Cのデバイス32点対応 | ○ | − | ○ | − |
+| ポインタ（P）デバイス256点対応 | − | − | − | ○ |
+
+ST言語対応は表記判定に影響しないため実装対象外です。残る2件は型名だけでは確定できないため、次のように分離しています。
+
+- 既定（`default`）はSERIALを未確認とみなし、拡張前の点数で判定します。範囲外だが拡張範囲内の場合は`ADDRESS_OUT_OF_RANGE`ではなく`REQUIRES_SERIAL_SUPPORT`を返し、`suggestedMode: "maximum"`を添えます。
+- `maximum`は拡張後の点数を許可しますが、成功時も`configurationDependent: true`とします。
+- `frFeatures.extendedTimerPoints` / `frFeatures.pointerDevice` に真偽値を渡した場合のみ、設定依存を解除して確定判定します。マニュアルが非対応としている型名に`true`を渡した場合は`INVALID_FR_FEATURES`を返します。
+
+FR-A800-Pは本文8ページの対応列から明示的に除外されているため、32点拡張の対象外として扱います。FR-A800 PlusのうちFR-A800-CRN/LC以外も同様に対象外です。
+
+### 桁指定
+
+本文125-126ページは、桁指定の対象をビットデバイス（X、Y、M）と明記し、16ビット命令でK1～K4、32ビット命令でK1～K8としています。本パッケージはK1～K8を受け付け、先頭デバイス＋指定点数がデバイス範囲を超える場合に`DIGIT_RANGE_OVERFLOW`を返します。本文127ページの例（`K5M0`、`K5M10`）のとおり先頭番号のアライメント制約はないため、そこは判定しません。
+
+### 入力デバイスXの属性
+
+本文22・25ページの注記は「入力デバイスXは、外部端子の入力状態をモニタします。例えば、X00をシーケンスプログラム上でONしてもSTF信号をONすることはできません」とし、信号入力にはSM1200、SM1255、SD1148、SD1149を使うよう指示しています。Xはネットワーク側の領域（`X30`以降）も含めて毎スキャンリフレッシュされる入力イメージであるため、`access: "read-only"`として扱い、`operation: "write"`では`operationAllowed: false`を返します。
+
+### 意図的な保守性
+
+- ビット指定、間接指定（`@`）、インデックス修飾（`Z`/`LZ`）、ローカルデバイス（`#`）、ユニットアクセス（`Un\G`）、CPUバッファアクセス（`U3En\G`）、リンクダイレクト（`Jn\`）は本マニュアルに記載がないため、すべて無効とします。
+- `TS`/`TC`/`TN`のような接点・コイル・現在値の分離表記も記載がないため無効とし、`T0`形式を案内します。
+- SM/SDは「機能制限あり」と注記されているとおり、全番号に機能が割り当てられているわけではありません。本パッケージは領域の範囲のみを判定します。
+
+### 積算タイマ（ST）の初期値0点
+
+本文11ページの積算タイマ行には注記*8が付き、12ページで「*8 初期値は0です。」と定義されています。IB-0600627-D 37ページおよびIB-0600870-S 132ページのSLMPデバイス表も、積算タイマの範囲を「0点（初期値。PCパラメータ割付けにより16点まで使用可能。）」としており、両者は一致します。
+
+このためSTのみ、他シリーズの点数変更可能デバイスと同じ扱いにしています。
+
+| モード | STの判定 |
+| --- | --- |
+| `default` | 有効点数0点。任意のST表記に対して`REQUIRES_CONFIGURATION`と`suggestedMode: "maximum"`を返します。 |
+| `maximum` | 割付け上限（16点、32点拡張対応機種では32点）まで許可し、`configurationDependent: true`とします。 |
+| `configured` | `configuredPoints.ST`の点数で判定します。未指定なら`MISSING_CONFIGURATION`、上限超過なら`INVALID_CONFIGURATION`です。 |
+
+T・Cには同様の注記がないため、これらは従来どおり固定範囲（16点／SERIAL依存で32点）として扱います。
+
+## FRインバータ SLMPデバイステーブル
+
+IB-0600627-D 37ページ（FR-A800-E/FR-F800-E）およびIB-0600870-S 132-133ページ（FR-E800）の「デバイス」表は、外部機器がSLMPで指定できるデバイスコードと範囲を規定しています。シーケンス機能のデバイス一覧とは範囲も表記も異なるため、`frAccess: "slmp"`で別テーブルとして判定します。
+
+| デバイス | コード | 種別 | 範囲 | 備考 |
+| --- | --- | --- | --- | --- |
+| SM | `H91` | ビット | `0-2047` | ワード単位指定時は特殊リレー一覧のデバイスNo.を先頭に指定する必要あり |
+| SD | `HA9` | ワード | `0-2047` | |
+| X | `H9C` | ビット | `H0-H7F` | シーケンス機能の`H0-H8F`より狭い |
+| Y | `H9D` | ビット | `H0-H7F` | 同上 |
+| M | `H90` | ビット | `0-127` | |
+| D | `HA8` | ワード | `0-255` | |
+| W | `HB4` | ワード | `0-8191`（8192点） | IB-0600870-S 132ページ。FR-E800側の表にのみ記載 |
+| TS / TC / TN | `HC1` / `HC0` / `HC2` | ビット / ビット / ワード | `0-15` | |
+| STS / STC / STN（SS / SC / SN） | `HC7` / `HC6` / `HC8` | ビット / ビット / ワード | 0点（初期値。割付けにより16点まで） | |
+| CS / CC / CN | `HC4` / `HC3` / `HC5` | ビット / ビット / ワード | `0-15` | |
+
+- IB-0600870-S 12ページは「Ethernet通信は、Ethernet仕様品、安全通信仕様品、IP67仕様品で使用可能です」と規定しています。SLMPを許可する型名は、これとIB-0600627-Dの適用範囲から FR-A800-E、FR-F800-E、FR-E800-E、FR-E800-SCE、FR-E806 に限定し、その他は`MODEL_NOT_SUPPORTED`とします。
+- 積算タイマの各部の表記は、IB-0600627-D 37ページが`STS`/`STC`/`STN`、IB-0600870-S 132ページが`SS`/`SC`/`SN`です。デバイスコードは同一（HC7/HC6/HC8）のため両表記を受け付け、選択した型名のマニュアル表記と異なる場合に警告を返します。
+- リンクレジスタWは、IB-0600870-S 133ページ以降でPr.番号（`W0-W999`）、モニタ、アラーム履歴、シリアルナンバー（`W8101-W8108`）等に対応づけられており、番号は10進です。PLCシリーズのWが16進であるのと異なるため、FR800では基数を分けています（FRで16進なのはX/Yのみ）。割付けは疎ですが、本パッケージは表が定める8192点の範囲のみを判定します。
+- 両マニュアルのSLMP表はT/CおよびSTの上限を16点としており、シーケンス機能側の32点拡張には言及していません。したがって`frAccess: "slmp"`では`frFeatures.extendedTimerPoints`で範囲を広げません。
+- SLMPは先頭デバイス番号と点数を別フィールドで送るため、桁指定は表記の一部ではありません。P・N・Lも表に存在しないため無効とします。
+
+インバータ間リンクの入出力割付け（`X40-X8F` / `Y40-Y8F`）は、IB-0600627-D 94ページとIB-0600870-S 222ページがシーケンス機能プログラミングマニュアルと同一の内容を示しており、判定値の変更はありません。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mokouliszt/mel-device",
-  "version": "0.3.1",
-  "description": "Model-aware Mitsubishi MELSEC and MELFA device notation validator.",
+  "version": "0.4.0",
+  "description": "Model-aware Mitsubishi MELSEC, MELFA and FR inverter device notation validator.",
   "license": "MIT",
   "author": "mokouliszt",
   "type": "module",
@@ -37,7 +37,11 @@
     "mx-r",
     "mx-f",
     "cr800",
-    "melfa"
+    "melfa",
+    "inverter",
+    "fr-a800",
+    "fr-f800",
+    "fr-e800"
   ],
   "engines": {
     "node": ">=18"