iobroker.yamaha 2.6.0 → 2.7.1

package/README.md

@@ -108,6 +108,12 @@ On the very first contact the adapter asks the receiver which functions it suppo
     Placeholder for the next version (at the beginning of the line):
     ### **WORK IN PROGRESS**
 -->
+### 2.7.1 (2026-09-09)
+
+- (krobipd) Improved: The first connection asks a receiver only what its generation can answer, so zones, trigger sockets and per-input settings follow the device, not a catalogue.
+- (krobipd) New: A datapoint the receiver reveals later now appears at once — a function it starts answering, a value it reports for the first time, a status field it begins delivering.
+- (krobipd) Changed: A datapoint that never carried a value is removed only after two starts confirm it, so a receiver left in standby no longer loses datapoints it still has.
+
 ### 2.6.0 (2026-09-09)
 
 - (krobipd) Fixed: input and sound program lists now offer only what the receiver itself declares or proves it has, instead of every value any Yamaha may have (#619)
@@ -136,11 +142,6 @@ On the very first contact the adapter asks the receiver which functions it suppo
 - (krobipd) Fixed: bass, treble and subwoofer trim showed doubled values on MusicCast receivers — that scale counts in half decibels and was labelled as decibels
 - (krobipd) Fixed: a receiver that was in standby when the adapter started could end up with an empty media menu until the next restart
 
-### 2.4.0 (2026-09-03)
-
-- (krobipd) New: the on-screen remote reaches every protocol now — the cursor pad and the menu keys work on YNCA and pre-2010 XML receivers, not just on MusicCast
-- (krobipd) Changed: stepping one menu level back no longer switches to a substitute key on a receiver that rejects it — on those models the new cursor pad does it
-
 [Older changelogs can be found there](CHANGELOG_OLD.md)
 
 ## History

package/build/lib/device-controller.js

@@ -158,6 +158,12 @@ class YncaDeviceController {
   presentSubunits = /* @__PURE__ */ new Set();
   /** The enum values this device ever reported (see OBSERVED_KEY), persisted on every addition. */
   observed = {};
+  /** The (group-filtered) catalog of this connection, for rebuilding objects mid-session. */
+  catalog = [];
+  /** The capability shape the current object tree was built from — grown by pushes and refreshes. */
+  shape = { model: "", subunits: {} };
+  /** Object id → the definition last upserted, so a republish writes only what really changed. */
+  published = /* @__PURE__ */ new Map();
   /**
    * Connect, sweep the device from the catalog, and create its object tree; wire
    * up push updates. The catalog is the single source: it drives the sweep, the
@@ -169,6 +175,7 @@ class YncaDeviceController {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     await this.deps.client.connect();
     const catalog = this.deps.isEntryEnabled ? import_catalog.YNCA_CATALOG.filter((entry) => this.deps.isEntryEnabled(entry.id)) : import_catalog.YNCA_CATALOG;
+    this.catalog = catalog;
     const resolved = await this.resolveCapabilities(catalog);
     const { capabilities, fromCache } = resolved;
     const present = (0, import_catalog.presentYncaEntries)(capabilities, catalog);
@@ -184,6 +191,7 @@ class YncaDeviceController {
     this.recordObservedAll(capabilities);
     this.recordObservedAll(live);
     const evidence = this.inputEvidence(capabilities);
+    this.shape = { model: capabilities.model, subunits: capabilities.subunits };
     const objects = (0, import_catalog.yncaObjectsFor)(capabilities, catalog, this.statesResolver(live, evidence));
     if (objects.length === 0) {
       this.deps.log.warn(`${this.deviceId}: no capabilities reported \u2014 creating no objects`);
@@ -212,7 +220,7 @@ class YncaDeviceController {
       if (titles !== void 0 && titles.length > 0) {
         object.common.states = Object.fromEntries(titles.map((scene) => [scene.num, scene.title]));
       }
-      await this.deps.upsertObject(`${this.deviceId}.${object.id}`, object);
+      await this.upsertTracked(object);
     }
     for (const zone of YNCA_ZONES) {
       const titles = zone.key === "main" ? this.sceneTitles : this.zoneSceneTitles.get(zone.key);
@@ -318,7 +326,8 @@ class YncaDeviceController {
       (_h = this.deps.probeMemory) == null ? void 0 : _h.set(CAPS_KEY, {
         model: capabilities.model,
         firmware: (_g = (_f = capabilities.subunits.SYS) == null ? void 0 : _f.VERSION) != null ? _g : firmware,
-        subunits: capabilities.subunits
+        subunits: capabilities.subunits,
+        complete: true
       });
     } else {
       (_i = this.deps.probeMemory) == null ? void 0 : _i.drop((key) => key === STATIC_KEY);
@@ -372,9 +381,9 @@ class YncaDeviceController {
    * subunits — the answers stream into the states through the live message handler,
    * so current values arrive within the usual sweep time WITHOUT having gated the
    * ready line. Completion refreshes the persisted layers (capabilities, statics)
-   * and the write map; a SHAPE change (a function newly answered) is only persisted —
-   * its object appears on the next start, because the unified tree is coordinated
-   * once per connect and a late upsert would not materialize.
+   * and the write map; a SHAPE change (a function newly answered) is persisted AND published —
+   * since 2.7.0 the objects are rebuilt from the grown shape and the handle re-coordinates the
+   * unified tree, so the datapoint appears in this session instead of one start later.
    *
    * @param catalog the (group-filtered) catalog
    */
@@ -385,7 +394,7 @@ class YncaDeviceController {
       const gets = (0, import_catalog.sweepGets)(catalog).filter(
         (get) => get.subunit === "SYS" || !cached || cached.subunits.includes(get.subunit)
       );
-      const fresh = await this.deps.client.readCapabilities(gets);
+      const fresh = await this.sweepInPasses((0, import_catalog.planSweep)(gets, this.inputEvidence({ model: "", subunits: {} })));
       if (!fresh.model) {
         return;
       }
@@ -403,10 +412,13 @@ class YncaDeviceController {
       (_g = this.deps.probeMemory) == null ? void 0 : _g.set(CAPS_KEY, {
         model: fresh.model,
         firmware: (_f = (_e = fresh.subunits.SYS) == null ? void 0 : _e.VERSION) != null ? _f : "",
-        subunits
+        subunits,
+        complete: true
       });
       this.presentEntries = (0, import_catalog.presentYncaEntries)({ model: fresh.model, subunits }, catalog);
       this.writeMap = (0, import_catalog.idToEntry)(this.presentEntries);
+      this.shape = { model: fresh.model || this.shape.model, subunits };
+      await this.republishObjects();
       const titles = sceneTitlesOf(subunits);
       if (JSON.stringify(titles) !== JSON.stringify(this.sceneTitles)) {
         this.sceneTitles = titles;
@@ -495,9 +507,11 @@ class YncaDeviceController {
       (get) => (get.subunit === "SYS" || present.has(get.subunit)) && !answered.has(`${get.subunit}:${get.func}`)
     );
     const remembered = (_a = this.deps.probeMemory) == null ? void 0 : _a.remembered(STATIC_KEY);
-    const swept = await this.deps.client.readCapabilities(
-      remembered ? gets.filter((get) => !STATIC_FUNC.test(get.func)) : gets
+    const plan = (0, import_catalog.planSweep)(
+      remembered ? gets.filter((get) => !STATIC_FUNC.test(get.func)) : gets,
+      this.inputEvidence(basic)
     );
+    const swept = await this.sweepInPasses(plan);
     const capabilities = {
       model: swept.model || basic.model,
       subunits: (0, import_capability.mergeYncaSubunits)(basic.subunits, swept.subunits)
@@ -519,6 +533,27 @@ class YncaDeviceController {
     (_c = this.deps.probeMemory) == null ? void 0 : _c.set(STATIC_KEY, statics);
     return capabilities;
   }
+  /**
+   * Send a planned sweep: the first pass, then — only for the SYS families whose head answered
+   * in it — the family members (`planSweep`, `SYS_FUNCTION_FAMILIES`). One GET on the head
+   * decides up to 43 GETs of a family a device has as a whole or not at all.
+   *
+   * @param plan the planned GET lists
+   * @returns the merged answers of both passes
+   */
+  async sweepInPasses(plan) {
+    const first = await this.deps.client.readCapabilities(plan.first);
+    const answeredHeads = import_catalog.SYS_FUNCTION_FAMILIES.filter((family) => {
+      var _a;
+      return ((_a = first.subunits.SYS) == null ? void 0 : _a[family.head]) !== void 0;
+    });
+    const second = plan.families.filter((get) => answeredHeads.some((family) => get.func.startsWith(family.prefix)));
+    if (second.length === 0) {
+      return first;
+    }
+    const members = await this.deps.client.readCapabilities(second);
+    return { model: first.model || members.model, subunits: (0, import_capability.mergeYncaSubunits)(first.subunits, members.subunits) };
+  }
   /**
    * Read every bundle of the present subunits (BASIC and SCENENAME per zone, SIGINFO/RDSINFO on
    * the tuner, METAINFO per player — see `bundleGets`) in ONE paced request list; the answers
@@ -591,6 +626,49 @@ class YncaDeviceController {
     }
     list.push(value);
     (_e = this.deps.probeMemory) == null ? void 0 : _e.set(OBSERVED_KEY, this.observed);
+    void this.republishObjects();
+  }
+  /**
+   * Rebuild this transport's objects from the shape it knows now and upsert them. Idempotent by
+   * construction: the transport adapter keeps the last definition per id, so an unchanged object
+   * is neither written nor signalled — only a real change reaches the handle's re-coordination.
+   * Silent before the tree stood (no shape yet) and while nothing is present.
+   */
+  async republishObjects() {
+    if (this.presentEntries.length === 0 || Object.keys(this.shape.subunits).length === 0) {
+      return;
+    }
+    try {
+      const objects = (0, import_catalog.yncaObjectsFor)(
+        this.shape,
+        this.catalog,
+        this.statesResolver(this.shape, this.inputEvidence(this.shape))
+      );
+      for (const object of objects) {
+        const titles = this.sceneTitlesFor(object.id);
+        if (titles !== void 0 && titles.length > 0) {
+          object.common.states = Object.fromEntries(titles.map((scene) => [scene.num, scene.title]));
+        }
+        await this.upsertTracked(object);
+      }
+    } catch (e) {
+      this.deps.log.debug(`${this.deviceId}: could not republish the object tree: ${String(e)}`);
+    }
+  }
+  /**
+   * Upsert an object and remember its definition, so the next republish writes only what really
+   * changed. A device answering a new value republishes the whole tree; without this every one of
+   * ~250 definitions would be handed on, and the handle would re-coordinate for each of them.
+   *
+   * @param object the object definition to write
+   */
+  async upsertTracked(object) {
+    const fingerprint = JSON.stringify(object);
+    if (this.published.get(object.id) === fingerprint) {
+      return;
+    }
+    this.published.set(object.id, fingerprint);
+    await this.deps.upsertObject(`${this.deviceId}.${object.id}`, object);
   }
   /**
    * What this connect learned about the device's inputs: the probe's verdicts (present /