- `cmd1`/`cmd2` insieme formano l'**opcode** (vedi §6). 🔎 confermato rispetto al frame builder
  dell'app ufficiale (`C6117b.m30831g`).
- `chunkCount` = numero totale di chunk per questo comando; `chunkIndex` è **1-based**.
- `chunkLen` = numero di byte di `chunk` in questo frame.
- Una singola scrittura BLE può essere frammentata dall'MTU del link; il ricevitore bufferizza i byte
  grezzi e ri-estrae i frame completi. I payload di grandi dimensioni vengono suddivisi in più chunk
  (stesso `cmd1/cmd2`, `chunkIndex` crescente) e riassemblati in ordine.

### Convenzione opcode (✅ confermata sul wire)

- `cmd1 = 0xFFFF`: `cmd2` in `0x80xx`/`0x90xx` = telefono→orologio (richiesta/impostazione); `0x00xx`/`0xa0xx` =
  orologio→telefono (risposta). Le coppie corrispondono tramite il byte basso (`0x9055`↔`0xa055`, `0x8051`↔`0x0051`).
- `cmd1` specifico della funzionalità: suffisso `cmd2` = `0x0001` **SET**, `0x0002` **GET**, `0x0003` **ACK**.

### Corpo del chunk

Per ogni chunk, il corpo è `payloadPiece ‖ CRC32_LE(payloadPiece)` (CRC a 4 byte, little-endian,
zlib/IEEE). Se il comando è **cifrato** (vedi §3), l'intero `payloadPiece ‖ CRC` viene poi
cifrato con AES-128-CBC/PKCS7 e quel ciphertext diventa il `chunk` del frame.

**Stranezza del plaintext:** per gli opcode in chiaro l'orologio *conta* il CRC a 4 byte in `chunkLen` ma
**non** lo trasmette. Quindi, decodificando un frame in chiaro, la lunghezza effettiva dei dati è `chunkLen − 4`.
(I frame cifrati trasportano il CRC all'interno del ciphertext come di consueto.)

Dimensionamento dei chunk (così i chunk cifrati cadono sui confini dei blocchi AES), con `maxWrite = mtu − 3`:
- cifrato: `floor((maxWrite − 11) / 16) * 16 − 4 − 1`
- in chiaro: `maxWrite − 11 − 4 − 1`

✅ Tutti i valori `chunkLen` dei frame cifrati osservati erano multipli di 16 (l'allineamento dei blocchi è rispettato).

---

## 3. Primitive crittografiche

- **AES-128-CBC** con padding **PKCS7** e un **IV fisso** (dal firmware
  `CmfCharacteristic.AES_IV`):
  `50 51 52 53 54 55 56 57 60 61 62 63 64 65 66 5A`.
- **CRC32** (zlib/IEEE), emesso come 4 byte little-endian.
- **SHA-256** sulla concatenazione delle parti.

Derivazione della chiave:```
authkey      = SHA256( rnd1 ‖ rnd2 ‖ secret )[0..16]      // persisted across sessions
sessionKey   = SHA256( nonce ‖ authkey )[0..16]           // per connection

In caso di `AUTH_FAILED (0xFFFF,0xA061)` o di mancata corrispondenza della firma, l'autenticazione fallisce.

### 4.2 Riconnessione (authkey già noto)```
        set crypto key = authkey (persisted)
phone → AUTH_PHONE_NAME      (encrypted)  payload = 0xA5 ‖ model
watch → AUTH_WATCH_MAC       (encrypted)
phone → AUTH_NONCE_REQUEST   (encrypted)  payload = 0xA5
watch → AUTH_NONCE_REPLY     (encrypted)  payload = nonce
        sessionKey = SHA256(nonce ‖ authkey)[0..16]   → set crypto key = sessionKey
phone → AUTHENTICATED_CONFIRM_REQUEST (encrypted)  payload = 0xA5
watch → AUTHENTICATED_CONFIRM_REPLY   (encrypted)  → Initialized

Finish reply byte: `01` = attivato e salvato; `0a` = memorizzato ma **non** attivato / rifiutato. Su
Android ogni `DATA_CHUNK_WRITE` deve uscire come **una scrittura BLE per frame** — concatenare e
ri-tagliare in base all'MTU desincronizza gli header e l'orologio continua a richiedere l'offset 0.

- **`9063` (foto) = APPEND.** La lista dei quadranti cresce (6→7); `watchfaceId = 0xFFFFFFFF` (sentinel
  personalizzato) così non viene mai rifiutato come duplicato, e l'orologio lo attiva automaticamente.
- **`9075` (strutturato) = SOSTITUISCE** lo slot `old_id`. `old_id` **deve** essere già nella lista
  (altrimenti `0a`). Per reinstallare un id già presente, **eliminalo prima** (9055 lista-meno-id)
  poi carica "da zero" — riutilizzare un id già presente dà `0a`.

### 11.3 Quadrante foto / personalizzato — ✅ completamente validato end-to-end

**Contenitore** (round-trip verificato byte per byte; tutti i campi little-endian):```
0x00  magic     6c 8d c4 a5
0x04  count     12 00 00 00   (=18)  [constant, NOT an element count]
0x08  00 × 8
0x10  lenFull   u32 LE        (length of the whole FULL block: tag+len+payload)
0x14  FULL  tag 04 48 47 3a ‖ payloadLen(u32 LE) ‖ LZ4(RGB565-LE)   → 466×466  [raw 434312 B]
      THUMB tag 04 38 c4 21 ‖ payloadLen(u32 LE) ‖ LZ4(RGB565-LE)   → 270×270  [raw 145800 B]
EOF-4 magic     6c 8d c4 a5   [trailer = magic repeated]

`size` = lunghezza esatta del `.bin`; `FFFFFFFF` = `watchfaceId` personalizzato; `styleId` 0–4 seleziona il layout
dell'orologio digitale integrato (viene sempre disegnato — non esiste uno stato "off"); `posX/posY` lo posizionano (valori noti
56 / 77); `color565` lo colora (es. `FFFF` = bianco). ⚠️ La forma più corta `A5 ‖ size ‖ watchfaceId` viene
**rifiutata** con esito `0a` — usa l'header completo sopra. (Implementazione di riferimento:
`core-rust/engine.rs::build_wf_init2`, che rispecchia `C6135t.m31104u` nell'app ufficiale.)

**Procedura:** ridimensiona l'immagine a 466×466 (e una miniatura 270×270), converti in RGB565-LE dall'alto verso il basso,
aziona facoltativamente i pixel fuori dal cerchio, comprimi ciascuna con LZ4, assembla il contenitore sopra e carica
tramite la pipeline `9063` con `watchfaceId = 0xFFFFFFFF`. (Codec di riferimento: `core-rust/watchface.rs`,
`work/codec_dfa.py`.)

### 11.4 Quadrante strutturato / da store — contenitore e codec ✅

**Struttura del file** — l'header di 36 byte viene ripetuto **byte-per-byte come footer di 36 byte** alla fine del file
(✅ verificato su 15 quadranti; un parser dovrebbe rifiutare un file in cui differiscono):```
[36-byte header][scene TLV (§11.7)][asset pool][36-byte header again]

> ⚠️ **Correzione (sostituisce "non esiste checksum bloccante").** Revisioni precedenti leggevano `@0x00` come
> un id/hash per-dial e `@0x20` come "3× parole u32 id/hash \[non un CRC]", e affermavano che CRC32/Adler32/
> byte-sum non corrispondono. Entrambe le parole **sono** CRC32 — i test precedenti le hanno mancate perché
> la variante non è standard, e perché la lettura "3 parole a `0x20`" confondeva l'unica parola CRC
> con i primi byte del contenitore della scena che inizia a `0x24` (allo stesso modo "nome ripetuto a
> `0x2c`" è il nodo nome `0x86` della scena, §11.11). Scoperta da
> [freethinkel/fmc](https://github.com/freethinkel/fmc); riverificata qui.

**CRC32-raw** = polinomio IEEE riflesso `0xEDB88320`, **`init = 0`**, e **nessun XOR finale** — cioè
né l'`init=0xFFFFFFFF` né il `^0xFFFFFFFF` del `crc32` standard. Questo è il motivo per cui
il CRC32 pronto all'uso non ha mai corrisposto. Nota la dipendenza dall'ordine: `crc_assets` si trova all'interno dell'intervallo
coperto da `crc_tree`, quindi **scrivi `@0x20` per primo, poi calcola `@0x00`**.```python
def crc32_raw(data: bytes) -> int:          # tab = standard 0xEDB88320 reflected table
    c = 0                                    # init 0, no final inversion
    for b in data: c = tab[(c ^ b) & 0xFF] ^ (c >> 8)
    return c & 0xFFFFFFFF

crc_tree   = crc32_raw(f[0x04:0x24] + f[0x24:first_asset])
crc_assets = crc32_raw(f[first_asset:len(f)-36])

`kind` = `0x02`/`0x03`; `old_id` = dial attivo corrente (da `9055`); `file_len` = dimensione reale del `.bin`
(= `@0x18 + 36`). Installare un `.bin` dello store così com'è è il percorso garantito (Ring Data id 359 +
102 altri confermati). (Riferimento: `core-rust/engine.rs::build_dial_replace_init`.)

### 11.5 Grammatica strutturata della directory ✅ (decodificata e implementata — REVISATA 2026-07-02)

> **⚠️ Revisione (2026-07-02): lo schema piatto del record `61 01 00` qui sotto era sistematicamente
> SBAGLIATO DI UNO.** Il corpo della scena è un TLV pulito (§11.7); un **corpo di foglia** disegnabile (tag `0x30`/`0x38`
> statici, puntatore `0x70`) è:
>
> ```
> 01 xx 00 [X u16][Y u16] …attrs… 61 [count u16][base u32][count×id u16] [05 05 00 01 pivX pivY]
> ```
>
> - l'attributo `0x01` apre il corpo: **X,Y = angolo in alto a sinistra** sulla tela 466² (gli `s16 x,y` dell'SDK
>   `sty_picture_t`).
> - la **tabella dei frame `61 …` chiude il corpo** (`base` = puntatore asset; `count` 1 = immagine, 10/11 =
>   atlante delle cifre — il vecchio "tipo di record `0a/0b`" era in realtà questo count! — 7/13/2 = foglio
>   dei frame della complicazione).
> - extra del puntatore: sorgente+scala `[src] 00 3c 00` dentro l'attributo `0x01`; pivot nel
>   **trailer** `05 05 00 01 [pivX][pivY]`. **Centro di rotazione = `(X+pivX, Y+pivY)` per puntatore** —
>   non un (233,233) fisso: esistono subdiali fuori centro (es. le lancette del dial 366 ruotano attorno a 150,150).
>
> La scansione lineare per `61 01 00` cuciva la tabella dei frame+pivot dell'elemento **N** alle X/Y
> (e al byte di tag, il vecchio "f3") dell'elemento **N+1** — sembrava *giusta* solo sui dial analogici i cui
> lancette adiacenti condividono geometrie quasi identiche. Il "muro della variante compatta" (spec 24 §24.4.5) era
> questo stesso fraintendimento. Implementato come `scan_scene_drawables` in `core-rust/watchface_struct.rs`
> e `wfweb/src/codec/parse.ts` (scena = fonte primaria per immagini/puntatori; scansione piatta mantenuta per
> testo + fallback non-envelope). Validato dall'oracolo `wfweb/compare.html` (render vs PNG ufficiali dello store, 99 dial): 64→72 buoni, 8→5 cattivi, diff media 9.3→7.4%.

Lettura storica del record piatto (superata, mantenuta per contesto):

- **Immagine statica** (`61 01 00`): `asset_ptr(u32) ‖ elemId(u16) ‖ 05 05 00 01 ‖ pivotX(u16) ‖
  pivotY(u16) ‖ 3B ‖ 01 ‖ 1b 00 ‖ X(u16) ‖ Y(u16)`. Angolo in alto a sinistra sulla tela 466² = `(X−pivotX, Y−pivotY)`.
- **Puntatore/lancetta** — stesso record immagine, ruotato a runtime. **Centro di rotazione = `(X+pivotX, Y+pivotY)`**
  (≈ 233,233 sui dial analogici). La **sorgente dati è un `u8` all'offset del record `+36`**, scala `u16` a
  `+38` (=60): `0x0a`/`0x70` = ora (`h·30°+m·0.5°`), `0x0e`/`0x71` = minuti (`m·6°+s·0.1°`),
  `0x12`/`0x72` = secondi (`s·6°`). ✅ confermato disassemblando i getter (fallback RTC 10:10:30).
- **Widget testo / numero** (`61 0a 00`): `asset_ptr(u32) ‖ [10×u16 metriche font] ‖ 40 01 00 ‖ flag ‖
  3B ‖ 01 ‖ u16 ‖ X(u16) ‖ Y(u16)`. `asset_ptr` punta al glifo "0"; la cifra *d* = l'asset a
  `index("0") + d` (10 sprite cf=5 consecutivi, es. `0123456789` e punteggiatura `,°`). ✅ renderizzato.
- **Riempimento complicazione = indice del frame** (✅ confermato per complicazioni a cifre/enum/gauge, count>1): il
  valore indicizza un **foglio di frame pre-renderizzato** nel `.bin` — `frame = (count−1)·val/100` (percentuale) o
  `frame = value` (cifra flip / enum). Tabella dei frame = sotto-record `61 ‖ count(u16) ‖ base(u32) ‖
  count×id(u16)`. Es. l'ora grande di 327 Digit Max è un foglio a 13 frame (numeri 0–12), `frame = hour`.
- **Anello di avanzamento / arco = clip settore runtime** (✅ 2026-07-02, **corregge la lettura "gli anelli sono fogli di frame"
  nella spec 25 §2**): il tag dell'elemento **`0x81`** porta un **singolo** disco pieno (`61` tabella dei frame
  `count == 1`), e il cuneo parziale è quel disco **ritagliato a settore circolare** (`frac = value/max`,
  in senso orario dalle 12) — verificato pixel per pixel su 322 Glare 2 e confermato `count==1` su
  **20 dial**. Su disco: corpo `0x81` = sotto `0x01` (geometria `x@+0 y@+2 w@+4 h@+6`, `61 1 base` inline
  = disco) + sotto `0x5b` (specifica arco). Implementato in wfweb (`blendSector`).
  ⚠️ Il sotto-record `0x5b` **non** è solo "`max` u16 `@+4`" come documentato in precedenza — quello leggeva la
  metà bassa di un `max i32` e perdeva gli **angoli di inizio/fine sweep e la larghezza del tratto** che stanno
  subito dopo. Esiste anche un fratello procedurale `0x80`/`0x5a` (con raggio esplicito) che questo
  documento non ha mai coperto. Layout completo del record, e cosa l'assunzione precedente "in senso orario dalle 12"
  sbagliava: **§11.15**.
- **Id della sorgente dati** — il blocco attributi `82` dell'elemento sta a `delim+3` (dopo l'ultimo `40 01 00`),
  e **l'id della sorgente è un `u8` a `+0x14`** (anche `relX@+0x07 s16`, `relY@+0x09 s16`, `anchor@+0x0C/0E`,
  `mode@+0x15`, `frame-count@+0x1A`). Anchor < 0 = allineamento al bordo del genitore. 🔎 Il firmware risolve
  l'id tramite una tabella di getter a 142 voci a `0x101f371c` (ognuna chiama `ux2sys_get(type)`).
  ⚠️ **Preferisci leggere l'id come `meta[9]` della struct (§11.11)** — un campo fisso — rispetto a questa
  scansione in avanti dell'attributo `82`, che è la fonte dell'errore di uno descritto in §11.8/§11.9. Tabella id completa in §16; nota
  che le etichette salute/meteo elencate inline in questa sezione (`0x19` FC, `0x1b` batteria,
  `0x24` temperatura, `0x36` passi) sono **contestate e probabilmente sbagliate** — vedi il riquadro ⚠️ in §16.
  (L'esempio del gruppo `0x07:0x0b:0x0f` = HH:MM:SS qui sotto non è influenzato.)
- **Nodo gruppo** (`0x68`): annida i suoi figli dentro il proprio corpo TLV (`0x60` = valore/testo,
  `0x30` = statico); ogni `0x60` porta il suo id sorgente a `data+16`. Es. un gruppo `0x07:0x0b:0x0f` =
  orologio HH:MM:SS. Parser elementi TLV = `0x100db55c` (tabella di salto indicizzata da `tag−0x70`).

### 11.6 Matrice di authoring

| Percorso | Stato | Note |
|---|---|---|
| Dial fotografico da qualsiasi immagine | ✅ **fatto** | §11.3; validato sul dispositivo |
| Installare uno qualsiasi dei 103 dial dello store | ✅ **fatto** | §11.4; `9075`, `old_id`=attivo |
| Reskin del background cf=4 di un dial dello store | ✅ **funziona live** | scambia il payload FULL in posizione, imposta la `len` dell'asset alla **nuova** dimensione del blocco (≤ vecchia), mantieni la stessa impronta del file, installazione pulita |
| Ri-authoring tramite template (scambia i pixel di qualsiasi layer + sposta la geometria) | ✅ **renderizza via BLE** | dial 373: bg→ciano + uno sprite cf=5→rosso + X spostato 224→100, tutto renderizzato, lancette live |
| Dial strutturato 100 %-sintetico da zero | ✅ **builder fatto, validato offline** | builder envelope `0x20` in `watchface_struct.rs` (`build_container`/`serialize`/`validate_container`); round-trip byte-exact su tutti i 103 dial + sintetico supera il validator del firmware (§11.7). 🟡 render on-device su `9075` non ancora filmato |
| Font di sistema (`.font`) | ✅ **decodifica/render (tutti)** | bin LVGL (non proprietario); 32 font numerici (`num*/nm*`, non compressi) + 24 font di testo (`font*`, LVGL RLE `comp=1`) tutti decodificati — 12208 glifi, 0 overrun, ASCII completo. RLE = LVGL v8.3 `lv_font_fmt_txt.c` (SINGLE/REPEATE/COUNTER a 3 stati + prefilter XOR per riga), portato 1:1, nessun disasm |

⚠️ Insidie di reskin/ri-authoring che causano schermo nero o `0a`: lasciare la **vecchia `len` dell'asset** (l'orologio
legge oltre il blocco → overrun → nero); **ingrandire il file** (rifiutato all'installazione); riusare un id
**in posizione** invece di un'installazione pulita; **riordinare gli asset** senza correggere la catena
delle dimensioni dei blocchi della coda di riferimenti (§11.11). Non fatale oggi ma scrivilo comunque correttamente: qualsiasi modifica alla scena o al pool di asset
invalida le due parole **CRC32** dell'header — ricalcola entrambe (§11.4), `@0x20` prima di `@0x00`.

### 11.7 L'envelope di scena `0x20` — decodificato e builder implementato ✅

Un dial **reale** ri-authorizzato renderizza perché preserva l'envelope di scena del file. Un corpo puramente sintetico
di record piatti `61 …` viene **rifiutato** — il parser del firmware (`WFManager_Parser`, `0xdb35c`)
richiede che il corpo (dall'offset `0x24`) inizi con un contenitore di scena `0x20`. Il file completo è:```
[0x00,0x24)  header:  perDialId@0 · version=1@4 · name[16]@8 · size_a@0x18 · size_b@0x1c · idWord0@0x20
[0x24, fa)   scene:   20 <u16 L0> ( 21 <u16 L1> ( 86 <len>=name , 30/70/80/81… drawables ) [ 22 … AOD ] )
[fa, EOF)    assets:  [dimsWord u32][len u32][payload = 1f 00 01 00 + LZ4] …
   size_a = filesize−36 · size_b = filesize−36−first_asset · 0x27+L0 == first_asset

> ✅ Questo unifica gli "offset magici" dei §11.5/§11.8/§11.9. Quelle sezioni individuano i campi *relativi
> al byte `0x61` della tabella dei frame* — che è semplicemente `+0x12` di questa struct, quindi `−18`/`−16` = `x`/`y` e
> **`−5` = `meta[9]`, l'id della sorgente**. Stessi byte, un unico layout pulito. L'euristica di scansione in avanti
> dell'attributo `82` che era sistematicamente sfasata di uno non serve affatto: basta leggere `meta[9]` della struct.
> Il `max` di un campo numerico è anch'esso semplicemente `meta[11..13]` (ad es. i campi giorno-del-mese portano `max = 99`).

**Coda di rif** (`61`) — come un nodo punta alle sue bitmap:```
+0x00  0x61      [tail type]
+0x01  count u16 [1 = single image · 10/11 = digit atlas · N = pick-list / frame sheet]
+0x03  base  u32 [ABSOLUTE FILE OFFSET of the first asset block]
+0x07  count × u16  = the BLOCK SIZE (8 + payload len) of each referenced asset, in order

`id` è un id di origine dati (§16) — inclusi gli **id di slot sintetici** del §11.13. Operatori, con
conteggi di occorrenza misurati su 15 quadranti:

| op | significato | visti |
|---|---|---|
| `0x01` | disegna se `value == val` | 99 |
| `0x81` | come `0x01` (bit `0x80` impostato — appare su varianti mutuamente esclusive) | 48 |
| `0x02` | **nascondi** se `value == val` | 7 |
| `0x03` | disegna se `value == val`, dove `val` è un **marcatore di assenza dati** (es. HR `1000`) | 13 |
| `0x05` | disegna se `value >= val` | 58 |
| `0x06` | disegna se `value <= val` | 50 |
| `0x04` | ⚠️ **sconosciuto** — 15 occorrenze, nessuna semantica confermata | 15 |

Regola di combinazione (come implementata dal renderer di riferimento, maschera `op & 0x7f`): le voci di
uguaglianza vengono combinate in **OR**, poi le voci hide/`>=`/`<=` devono **tutte** essere soddisfatte.

Questo singolo meccanismo copre gran parte della variabilità runtime del formato e spiega strutture che
sembrano widget duplicati:

- **Layout 12h / 24h e metrico / imperiale** — due set di widget impilati nello stesso punto, ciascuno
  legato a `id 0x73` (il flag delle unità) con `val` 0 o 1. Il quadrante 275 ha sei di queste coppie (12 nodi).
- **Segnaposto "Nessun dato"** — op `0x03` contro un sentinella, es. `id 0x5f, val 1000` (quadrante 275, due volte):
  disegna l'arte del trattino lungo invece di una temperatura quando la metrica non è disponibile.
- **Evidenziazioni a bucket** — un intervallo accoppiato `0x05`/`0x06`, es. la catena di Metaball dove ogni anello si
  illumina per la propria finestra di 5 minuti.
- **Alternate per slot di complicazioni** — legate agli id di slot sintetici del §11.13.

### 11.13 Slot di complicazioni configurabili — `0x85` + `0x5f` ✅ (sostituisce §11.8)

Il §11.8 concludeva che la metrica attiva di una complicazione configurabile è stato RAM del dispositivo e non poteva
essere recuperata dal file. **Ciò era sbagliato** — sia il menu delle metriche dello slot sia la sua selezione predefinita
sono nel `.bin`. Ogni nodo `0x85` porta un fratello `0x5f`:```
+0x00  slotIndex u8   [0-based position among sibling 0x85 nodes]
+0x01  count     u8   [how many metrics this slot offers]
+0x02  activeIdx u8   [index into the list below = the DEFAULT SHOWN METRIC]
+0x03  count × u8     [the metric ids themselves (§16)]           … NUL padding

L'accoppiamento è rigido: `0x80` trasporta sempre esattamente `0x01` + un `0x5a` da **19 byte**, `0x81` sempre esattamente `0x01` + un `0x5b` da **17 byte** (✅ 26/26 anelli su 15 quadranti). ⚠️ Ma il **`0x81` ritagliato dall'immagine domina** — 25 di quei 26. La variante procedurale `0x80`/`0x5a` è apparsa **una volta** (quadrante 273), quindi il suo campo `radius` e il layout da 19 byte si basano su un singolo campione; trattala con sospetto finché non la rivedi.

`frac = clamp((valore − min) / (max − min), 0, 1)`, e l'arco riempito va da `start` verso `end`.
L'angolo zero è alle **3 in punto**, positivo in senso orario. Esempi misurati:

| quadrante | tag | min..max | start → end | larghezza | raggio |
|---|---|---|---|---|---|
| 273 Activity Mood | `0x5a` | 0..100 | **−102,8° → 102,8°** | 42 | 222 |
| 273 Activity Mood | `0x5b` | 0..100 | 270,0° → 90,0° | 80 | (immagine) |
| 276 Dichotomy | `0x5b` | 0..100 | 60,0° → −120,0° | 23 | (immagine) |
| 304 Elaborate 2 | `0x5b` | 0..100 | −2,0° → 358,0° | 24 / 80 | (immagine) |
| 366 Combo | `0x5b` | 0..100 | 0,0° → 270,0° | 18 | (immagine) |
| 368 Function | `0x5b` | 0..100 | 0,0° → 360,0° | 20 | (immagine) |

> ⚠️ **Questo corregge l'assunzione "in senso orario dalle 12 in punto"** nel §11.5. Quello è solo il caso
> speciale `start = 0, end = 3600` (una scansione completa, dove la convenzione è inosservabile). I quadranti reali usano
> **indicatori parziali** (il ventaglio ±102,8° del 273, l'anello a tre quarti da 270° del 366) e **scansioni negative**
> (60° → −120° del 276), quindi un renderer che esegue sempre una scansione completa del cerchio dall'alto li disegna in modo errato.
> 🟡 La convenzione esatta dell'angolo zero e la regola di direzione provengono dal renderer di fmc, incrociate
> con questi valori su disco — non verificate indipendentemente pixel-per-pixel sul dispositivo da questo repository.
> Nota che `frac = valore/max` e il ritaglio del settore `0x81` nel §11.5 **sono stati** validati (quadrante 322).

⚠️ **Non risolto: il trailer a 3 byte `01 00 kk`.** `kk` assume valori dall'aspetto plausibile (104, 152, 216,
232, 248) e l'ipotesi ovvia è un raggio — **testata e confutata**: il quadrante 366 usa `kk = 104`
sia per un anello 82×82 che per uno 166×166, e il quadrante 273 usa `kk = 232` sia per un anello 440×440 che per uno 284×284.
Non è un raggio, non è un diametro. Possibilmente opacità/stile. Reinstradalo così com'è.

🟡 **Insidia segnalata, non verificata qui:** nel renderer di fmc, un numero `0x60` il cui id sorgente è uguale all'id di **qualsiasi** anello sullo stesso schermo renderizza `round(frac × 100)` invece del valore grezzo — quindi un numero di frequenza cardiaca accanto a un anello di frequenza cardiaca mostra `36` invece di `71 bpm`. La loro soluzione documentata è di mettere l'anello e il numero su due id **alias** della stessa metrica (passi `0x19`/`0x26`/`0x49`, calorie `0x1c`/`0x1e`/`0x48`). Se questo sia un comportamento del firmware o specifico del loro renderer **non è stabilito** — vale un controllo dal vivo prima di progettare attorno a questo.

---

## 12. Dettagli sul trasferimento bulk e OTA

La tabella di trasferimento è nel §6. Punti aggiuntivi confermati:

- **AGPS/EPO** ✅: il primo blocco scritto inizia con l'header ASCII `000000010000…`. Il ciclo completo init → `[A05F ↔ 905F]×N` → finish è stato osservato sul filo (~892 blocchi).
- **OTA del firmware** (`9040`–`9042`, finish `9041`) 🔎: struttura mappata; payload INIT2 = byte di versione (es. `0b 00 00 39` = 11.0.0.57). **Non testato sul campo** (l'app disabilita l'aggiornamento FW qui). Le immagini del firmware sembrano essere **non firmate — l'integrità è solo CRC32** (nessuna firma asimmetrica osservata nella RE).
- ⚠️ Poiché OTA e `FACTORY_RESET (009A 0001)` condividono la sessione autenticata, una singola autenticazione BLE valida è sufficiente per cancellare o (in linea di principio) brickare l'orologio. Maneggia con cura.

---

## 13. Sensori

✅ Hardware esposto via BLE:

- **PPG ottico** — frequenza cardiaca (manuale/automatica/allenamento/riposo), SpO₂ e stress derivato da HRV.
- **Accelerometro a 3 assi** — passi, distanza, calorie, fasi del sonno, alzata del polso, cadenza.
- **GNSS/GPS** (assistito da AGPS) — traccia dell'allenamento (`WORKOUT_GPS`) e push della posizione (`GPS_PUSH`).

Non c'è **barometro/altimetro, bussola, giroscopio o sensore di temperatura cutanea/corporea**. Un termistore NTC interno (temperatura della scheda/batteria) esiste ma è leggibile **solo** tramite il canale AT (`AT GETNTCTEMP`, §14) — il flusso della cronologia della temperatura cutanea `0155` è vuoto su questo SKU.

**Dirottamenti dei widget dati** (non esiste una vera API di complicazioni/data-binding — vedi §11.5): i campi di testo esistenti dell'orologio possono essere riutilizzati per mostrare dati esterni a colpo d'occhio. Provato ✅: la stringa della **città meteo** (`WEATHER_SET_1`, es. `"BRA 2x1 ARG"` è apparsa sul widget) e i campi **traccia/artista** della musica; l'elenco dei **contatti** (20 × nome[32]+numero[25]) funziona come pannello dati scorrevole. Sono tutti push, non complicazioni persistenti.

---

## 14. Canale shell AT di fabbrica (`77d4ff01` / `77d4ff02`)

Un canale di comandi AT in testo semplice separato, indipendente dal protocollo incorniciato. ✅ testato dal vivo:

- **Lettura:** `AT GETSECRET` (segreto di accoppiamento a 16 byte), `GETVERSION`, `GETSN`, `GETNAME`, `GETPID`,
  `GETBATLV` (mV grezzi, es. `3853mv`), `GETGSENSOR` (accelerazione grezza in g, `X=… Y=… Z=…`),
  `GETNTCTEMP` (°C, NTC interno).
- **Scrittura / attuazione:** `AT SETMOTOR=1` (fai vibrare il motore), `SETHR/SETHRV/SETSPO2=…` (iniezione di test del sensore), `SETLCDSWITCH/SETGPSSWITCH/SETKEYSWITCH`.

Le risposte terminano con `,OK`. I comandi `SET*` generalmente si eseguono ma potrebbero non restituire `,OK` via BLE — conferma caso per caso.

---

## 15. Funzionalità limitate dal firmware / non disponibili (🔎 RE del firmware)

Alcune funzionalità sono presenti nel firmware ma disabilitate da SKU/regione e **non sono raggiungibili dal telefono/BLE** — richiedono una modifica del firmware, che è fuori ambito qui:

- **Voce ChatGPT** — gate = id funzionalità `ux2sys` `0x9e`, inizializzato da NVRAM/EFUSE/regione all'avvio; su questo SKU il flag di supporto `908b = 00`. Non influenzabile da telefono, account o BLE (confermato da esperimento + RE). L'app è solo un relay; l'audio va telefono → cloud Nothing.
- **Pressione sanguigna** — esiste un sottosistema completo nel firmware, disattivato da SKU/regione.
- **Alipay / pagamento NFC** — UI completa presente, solo SKU Cina.
- **Assenti in hardware/firmware:** ECG, SOS/emergenza, NFC generico.

---

## 16. Id getter per sorgenti dati / complicazioni

Non necessario per costruire un client BLE, ma **essenziale per creare o renderizzare un quadrante**: questo è il valore di `meta[9]` (§11.11) che lega un widget ai dati live, l'`id` di una condizione di visibilità (§11.12) e le voci del menu metriche di uno slot (§11.13). Il firmware lo risolve tramite una **tabella di dispatch getter a 142 voci** a `0x101f371c`, ogni voce chiama `ux2sys_get(type)` (🔎 RE del firmware).

### Ora / data — ✅ ben consolidato

| id | significato | id | significato |
|---|---|---|---|
| `0x01` | ora (12/24h secondo l'impostazione del dispositivo) | `0x0f`, `0x12` | secondo (fluido) |
| `0x04` | ora (24h) | `0x10`, `0x11` | decine / unità dei secondi |
| `0x07` | ora (24h forzato) | `0x71`, `0x72` | secondo (ticchettio / angolo lancetta) |
| `0x02`, `0x03` | decine / unità ora-12h | `0x13` | flag AM/PM (0 = AM, 1 = PM) |
| `0x05`, `0x06`, `0x08`, `0x09` | decine / unità dell'ora | `0x15`, `0x16` | mese |
| `0x0a`, `0x70` | angolo lancetta ore | `0x17` | giorno del mese |
| `0x0b` | minuto | `0x18` | giorno della settimana (0 = lunedì ⚠️) |
| `0x0c`, `0x0d` | decine / unità dei minuti | `0x0e`, `0x71` | angolo lancetta minuti |

Gli id decine/unità disegnano una **singola cifra** — un widget legato a uno di essi renderizza un glifo, non l'intero valore (quadrante 284 Square). Gli id angolo lancetta (§11.5) sono `0x0a`/`0x70` ore = `h·30° + m·0,5°`, `0x0e`/`0x71` minuti = `m·6° + s·0,1°`, `0x12`/`0x72` secondi = `s·6°` (✅ confermato disassemblando i getter, fallback RTC 10:10:30).

### Salute / sensori / meteo — ⚠️ contestato, leggi la colonna delle prove

| id | significato (migliore lettura attuale) | prove |
|---|---|---|
| `0x19` | **passi** | nel menu slot del 368 insieme a `0x1a`; corrisponde a `parse.ts` di questo repo |
| `0x1a` | **frequenza cardiaca** | nel menu slot del 368 insieme a `0x5f` e `0x19` |
| `0x1c` | calorie | menu slot, icona fiamma nell'app companion |
| `0x1e` | calorie (alias) | corpus |
| `0x22` / `0x23` | distanza km / mi (parte intera) | corpus |
| `0x74` / `0x75` | distanza km / mi (parte frazionaria) | corpus |
| `0x76` | distanza (forma slot) | menu slot, icona strada |
| `0x24` | **% batteria** | menu slot, icona fulmine |
| `0x30` | % batteria | corpus |
| `0x36` / `0x5f` | temperatura | `0x5f` = menu slot, icona nuvola-sole; 361 TempoG lega un numero semplice |
| `0x48` | ore in piedi (ore in piedi) | menu slot, icona figura in piedi |
| `0x8b` | AQI | menu slot |
| `0x73` | flag 24h / unità metriche | corpus |
| `0x25`–`0x27`, `0x49`, `0x6c`, `0x6f` | % obiettivo / alias slot di passi e calorie | corpus |
| `0x6a` | ⚠️ metrica slot non identificata | appare in 4 menu slot |
| `0x79 + slotIndex` | **sintetico** — non una metrica; l'id di selezione slot (§11.13) | ✅ §11.13 |

> ⚠️ **Tre tabelle in questo repo erano in disaccordo; questa è la riconciliazione.** Revisioni precedenti del §16
> e del §11.5 leggevano `0x19` come frequenza cardiaca, `0x1b` come batteria, `0x24` come temperatura e `0x36` come passi —
> e `wfweb/src/codec/mock.ts` codifica ancora quella lettura, mentre `wfweb/src/codec/parse.ts` ne codifica una
> diversa (`0x19` passi, `0x24` % obiettivo, `0x48` ore in piedi, `0x1a` meteo). La tabella sopra segue
> la lettura con prove migliori (etichette calibrate da fmc contro i menu icona degli slot widget dell'app companion, vedi §Fonti). **Il codice non è stato ancora modificato — `mock.ts` e `parse.ts` sono ancora incoerenti tra loro e con questa tabella.** Tratta le etichette degli id salute come ⚠️ finché qualcuno non lega un campo a ciascun id e legge l'orologio.
>
> La prova singola più forte è **il menu slot del quadrante 368 Function** (§11.13), che offre
> `0x5f 0x1c 0x19 0x48 0x24 0x76 0x1a 0x8b` come **otto metriche distinte selezionabili dall'utente** in un unico menu.
> Qualunque siano le etichette, nessuna coppia di quegli otto può essere la stessa metrica — il che esclude
> `0x19` = `0x1a` = frequenza cardiaca e `0x24` = `0x5f` = temperatura simultaneamente.

Le complicazioni ad anello/arco con un **foglio di frame** indicizzano un frame pre-renderizzato (es. 50 % = frame 50 di 100)
incorporato nel `.bin` che invii (§11.5), quindi non serve un pacchetto RES esterno; gli anelli senza immagine vengono disegnati
dalla specifica dell'arco invece (§11.15).

---

### Quick-cards (tile home) — `QUICK_CARD (906D)` ✅

Le tile home dell'orologio. Il telefono sceglie solo **quali** tile mostrare e in **che ordine** — le tile sono
renderizzate dal firmware (nessun canale di contenuto). Primo byte del payload = sottocomando: `00` = GET, `01` =
SET; **entrambi usano `0x906D`** (`0x906C` è elencato ma non usato — interrogarlo va in timeout). Risposta = `A06D`.

> 🛑 Inviare un `assemblyId` inventato **cancella gli schermi dell'orologio** (accetta l'elenco, non può abbinare
> gli id, non mostra nulla). Invia solo id che **rileggi** tramite GET; recupera tramite l'app ufficiale o un
> reset di fabbrica.

**Risposta GET** ✅: `status(1) ‖ 00 ‖ N(1) ‖ N × gruppo`, gruppo = `tag=01 ‖ K(1) ‖ K×(assemblyId, sportId)`.
Frame reale: `01 00 04  01 02 5d00 6100  01 03 1900 2e00 2300  01 03 5c00 0400 5a02  01 03 4800 5100 5300`
= 4 schermi / 11 card (`5a02` = card Sport, sportId 2).

**Slot:** ogni schermo ha **4 slot**. Il tipo di una card imposta la sua dimensione — `circolare`/`quadrata` = 1 slot,
`rettangolo` = 2 slot. La validazione è pura aritmetica degli slot (Σ ≤ 4 per schermo); nessuna card mutuamente esclusiva. `sportId` è `0` tranne sulle card Sport (87–91). Gli id `64` e `95` non esistono.

**Catalogo `assemblyId`** (ogni tipo logico = un intervallo contiguo di 6 varianti di stile `_0`..`_5`;
`0` = slot vuoto):

| dec | card | dec | card |
|----|----|----|----|
| 0 | slot vuoto | 49–53,97–98 | Meteo |
| 1–6 | Passi | 54–58 | Timer |
| 7–12 | Calorie | 59–62 | Respirazione |
| 13–18 | In piedi | 63,65–67 | Cronometro |
| 19–24 | Attività moderata | 68–71 | Batteria |
| 25–30 | Frequenza cardiaca | 72–76 | Recenti |
| 31–36 | SpO₂ | 77–81 | Contatti |
| 37–42 | Stress | 82–86 | Quadrante / telefono |
| 43–48 | Sonno | 87–91 | Sport (`sportId` ≠ 0) |
| 92 | Musica | 93/94/96 | Registro attività / PAI / Ciclo |

---

## Appendice A. Catalogo quadranti stock (id → nome)

Il §11 si riferisce ai quadranti con id numerico in tutto il documento (275 SlopeTime, 322 Glare 2, 357 Silhouette, …). Gli id
`273`–`376` sono i volti del negozio/stock; l'id è ciò che `DIAL_COMMAND (9055/a055)` riporta come attivo e
ciò che `9075` accetta come `old_id` (§11.4). 100 dei 103 id noti sono nominati sotto; i restanti sono
stub ROM (§11.4). Nomi e raggruppamenti come mostrati dall'app companion ufficiale.

- **Predefinito** (6) — `273` Activity Mood · `274` Sun Circle · `275` SlopeTime · `276` Dichotomy · `277` Prismatic Time · `280` Multifunction
- **Analogico** (34) — `286` Sundial · `287` Simple Dial · `292` City · `294` Sudoku · `305` Dots · `306` Large Number · `309` Gradient · `310` Glare · `311` Bold · `313` Classical · `314` Fragment · `315` Infinite · `316` Trailing · `322` Glare 2 · `326` Chrono Master · `327` Digit Max · `328` Coherent · `329` Wheel · `330` Zenith · `331` Intersection · `335` Time Phase · `336` Energetic · `338` Chronos · `341` Dual View · `346` Time Windmill · `347` Large Panel · `349` Theatre · `352` Elegant Sweep · `360` Explorer · `364` SportPulse · `370` Hemisphere · `371` ActiveTrio · `372` Time Wheel · `373` Traditional Pointer
- **Digitale** (41) — `281` Metaball · `282` Radar Sweep · `283` Radio · `285` Widgets · `288` Type · `289` Rotate · `290` Gradual · `291` Vertical · `293` Stairs · `296` Ladder · `297` Ray · `298` Eclectic · `299` Echo · `300` Mono Dial · `301` Orbit · `302` Calendar · `303` Space · `307` Sprung · `308` Sundial 2 · `319` One Line · `320` Orienteer · `321` Revolution · `323` Dash · `324` Finesse · `325` Metric · `333` Circularity · `334` Globe of Time · `337` Time Finder · `339` Suprematism · `340` Sport Mode · `345` Time Dot · `350` Timeline · `351` Cyclopes · `353` Dual phase · `357` Silhouette · `359` Ring data · `361` TempoG · `362` Steady · `365` Elegance · `369` Solar System · `376` Digits time
- **Multifunzione** (10) — `304` Elaborate 2 · `344` InfoMeter · `348` Tumbler · `354` Dual · `363` Vintage · `366` Combo · `367` Complex Figure · `368` Function · `374` Cirquary · `375` InfoHub
- **Creativo** (8) — `284` Square · `312` Disc · `317` Disc 2 · `318` Dominos · `332` Flux · `342` Perfect Match · `343` Progress Day · `358` Asteroid
- **Diwali** (1) — `295` Vortex

---

## Fonti

I layout dei byte sopra sono stati ricostruiti dal firmware (1.0.0.73), dall'APK ufficiale (3.5.7) e da
catture live decriptate contro un dispositivo reale. L'implementazione di riferimento per questo progetto vive in
`core-rust/src/{commands,frame,crypto,health,session}.rs` (Rust), l'editor TypeScript `wfweb/` e
gli strumenti Python `cmftool/` (`pair.py`, `session.py`, `wf_codec.py`, `upload_custom.py`, …).

**Lavoro indipendente incorporato qui.** [freethinkel/fmc](https://github.com/freethinkel/fmc) — un
editor di watchface SvelteKit + marketplace per lo stesso orologio — ha indipendentemente fatto reverse engineering del
formato `.bin` da un corpus di ~100 volti e ha raggiunto diversi risultati che questo documento mancava o aveva
sbagliato. I loro `docs/cmf-protocol.md`, `src/lib/modules/editor/lib/{wf,render}.ts` e
`src/lib/modules/device/lib/ble.ts` valgono la lettura diretta. Risultati adottati, ciascuno ri-verificato
contro i byte dei quadranti prima di essere scritto qui:

| Risultato | Dove | Stato qui |
|---|---|---|
| Entrambe le parole header sono CRC32 (variante non standard) | §11.4 | ✅ ri-verificato 9/9 quadranti; **corregge** "nessun checksum bloccante" |
| Condizioni di visibilità, tag `0x02` | §11.12 | ✅ ri-verificato; era non documentato |
| Elenco metriche slot + `activeIdx` predefinito, `0x79 + slotIndex` | §11.13 | ✅ ri-verificato su 275/368/273/304; **sostituisce** §11.8 |
| Flag capacità tinta accento `meta[7] == 4` | §11.14 | ✅ prevalenza ri-verificata; era non documentato |
| Specifica arco completa (angoli di scansione, larghezza, raggio) | §11.15 | ✅ ri-verificato; **corregge** "`max` u16 `@+4`" |
| I `u16` della coda ref sono dimensioni dei blocchi, non id glifo | §11.11 | ✅ ri-verificato esattamente su un atlante a 10 glifi |
| Footer a 36 byte; variante magic byte `0x02`; `0x86` = 64 B; anteprima incorporata `0x28` | §11.4, §11.11 | ✅ ri-verificato |
| Etichette id salute/meteo calibrate contro il menu slot dell'app companion | §16 | ⚠️ adottato come migliore lettura; conflitti segnalati |
| L'UUID del servizio shell è `77d4e67c-…`, e l'ambito `optionalServices` di Web Bluetooth | §1 | ⚠️ report a unità singola, non ri-verificato qui |
| Numero che condivide l'id con l'anello renderizza una percentuale | §11.15 | 🟡 segnalato, **non** verificato qui |
| Catalogo id → nome quadranti stock | Appendice A | ✅ adottato così com'è |