@khalido/home 0.1.3 → 0.2.1

package/dist/connectors/printers/raster.js

@@ -0,0 +1,175 @@
+// PWG Raster (PWG 5102.4), 8-bit grey only: what an AirPrint printer that lists `image/pwg-raster` takes when it lists no
+// PDF. A file is "RaS2", then per page a 1796-byte big-endian header and the page's pixels, compressed line by line:
+// a line-repeat byte (the line appears n + 1 times), then runs: 0 to 127 is one pixel repeated n + 1 times, 129 to 255 is
+// 257 − n pixels as they are. Checked against a page macOS's own filters made for a Brother (test/fixtures/printers).
+const HEADER = 1796;
+const SGRAY = 18; // cupsColorSpace for sgray (PWG 5102.4 table 9)
+const WHITE = 0xffffff; // AlternatePrimary: the white point, as PWG 5102.4 recommends
+/** A PWG media name's size in inches: `iso_a4_210x297mm` is 8.27 × 11.69. */
+function mediaInches(name) {
+    const m = /_(\d+(?:\.\d+)?)x(\d+(?:\.\d+)?)(mm|in)$/.exec(name);
+    if (!m)
+        throw new RangeError(`not a PWG media size: ${name}`);
+    const per = m[3] === "mm" ? 1 / 25.4 : 1;
+    return { width: Number(m[1]) * per, height: Number(m[2]) * per };
+}
+/** The pixels a page of this media is at its resolution, rounded down as macOS's filters do: A4 at 600 dpi is 4960 × 7015. */
+export function mediaPixels(media) {
+    const i = mediaInches(media.name);
+    return {
+        width: Math.floor(i.width * media.dpi),
+        height: Math.floor(i.height * media.dpi),
+    };
+}
+function header(page, media, total) {
+    const h = new Uint8Array(HEADER);
+    const v = new DataView(h.buffer);
+    const u32 = (offset, n) => v.setUint32(offset, n);
+    const str = (offset, s) => h.set(new TextEncoder().encode(s).subarray(0, 63), offset);
+    const pt = mediaPixels({ name: media.name, dpi: 72 }); // PageSize is in points
+    str(0, "PwgRaster"); // MediaClass
+    u32(276, media.dpi); // HWResolution
+    u32(280, media.dpi);
+    u32(340, 1); // NumCopies: copies are the job's, not the page's
+    u32(352, pt.width); // PageSize, points
+    u32(356, pt.height);
+    u32(372, page.width); // Width, Height in pixels
+    u32(376, page.height);
+    u32(384, 8); // BitsPerColor
+    u32(388, 8); // BitsPerPixel
+    u32(392, page.width); // BytesPerLine
+    u32(400, SGRAY); // ColorSpace; ColorOrder (396) 0 is chunky
+    u32(420, 1); // NumColors
+    u32(452, total); // TotalPageCount
+    u32(456, 1); // CrossFeedTransform
+    u32(460, 1); // FeedTransform
+    u32(480, WHITE); // AlternatePrimary
+    str(1732, media.name); // PageSizeName
+    return h;
+}
+/** One line's runs, appended to `out`. */
+function packLine(line, out) {
+    let i = 0;
+    while (i < line.length) {
+        let run = 1;
+        while (run < 128 && i + run < line.length && line[i + run] === line[i])
+            run++;
+        if (run > 1 || i + 1 === line.length) {
+            out.push(run - 1, line[i]);
+            i += run;
+            continue;
+        }
+        // Literal: up to 128 pixels, stopping before two equal pixels that would pack better as a repeat.
+        let n = 1;
+        while (n < 128 &&
+            i + n < line.length &&
+            !(i + n + 1 < line.length && line[i + n] === line[i + n + 1]))
+            n++;
+        if (n === 1) {
+            out.push(0, line[i]); // a lone pixel is a repeat of one: 257 − 256 can't be written
+            i += 1;
+            continue;
+        }
+        out.push(257 - n);
+        for (let k = 0; k < n; k++)
+            out.push(line[i + k]);
+        i += n;
+    }
+}
+/**
+ * Pages as one PWG Raster document, `image/pwg-raster`. Every page must be `width × height` bytes. Pages may come one at
+ * a time (a generator), so only the packed document and the current page are held; then `total` is the page count.
+ */
+export function pwgRaster(pages, media, total = Array.isArray(pages) ? pages.length : 0) {
+    const chunks = [new TextEncoder().encode("RaS2")];
+    for (const page of pages) {
+        if (page.pixels.length !== page.width * page.height)
+            throw new RangeError(`a ${page.width} × ${page.height} page needs ${page.width * page.height} bytes, got ${page.pixels.length}`);
+        chunks.push(header(page, media, total));
+        let y = 0;
+        while (y < page.height) {
+            const line = page.pixels.subarray(y * page.width, (y + 1) * page.width);
+            let repeat = 0;
+            while (repeat < 255 &&
+                y + repeat + 1 < page.height &&
+                equal(line, page.pixels.subarray((y + repeat + 1) * page.width, (y + repeat + 2) * page.width)))
+                repeat++;
+            const out = [repeat]; // one line at a time: a page as a number[] would be hundreds of MB
+            packLine(line, out);
+            chunks.push(Uint8Array.from(out));
+            y += repeat + 1;
+        }
+    }
+    const size = chunks.reduce((n, c) => n + c.length, 0);
+    const file = new Uint8Array(size);
+    let at = 0;
+    for (const c of chunks)
+        (file.set(c, at), (at += c.length));
+    return file;
+}
+function equal(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/** A PWG Raster document back as pages and their headers' key fields; for tests and for checking a file before it prints. */
+export function readPwgRaster(file) {
+    const text = new TextDecoder();
+    if (text.decode(file.subarray(0, 4)) !== "RaS2")
+        throw new Error("pwg raster: no RaS2 sync word");
+    const pages = [];
+    let at = 4;
+    while (at < file.length) {
+        const v = new DataView(file.buffer, file.byteOffset + at, HEADER);
+        const width = v.getUint32(372);
+        const height = v.getUint32(376);
+        const bitsPerPixel = v.getUint32(388);
+        const bytes = bitsPerPixel / 8;
+        const name = file.subarray(at + 1732, at + 1796);
+        const pageSizeName = text.decode(name.subarray(0, name.indexOf(0)));
+        const page = {
+            width,
+            height,
+            dpi: v.getUint32(276),
+            pageSizeName,
+            colorSpace: v.getUint32(400),
+            bitsPerPixel,
+            pixels: new Uint8Array(width * height * bytes),
+        };
+        at += HEADER;
+        const lineBytes = width * bytes;
+        let y = 0;
+        while (y < height) {
+            const repeat = file[at++] + 1;
+            const line = new Uint8Array(lineBytes);
+            let x = 0;
+            while (x < lineBytes) {
+                const c = file[at++];
+                if (c === 128) {
+                    line.fill(255, x); // the rest of the line is white
+                    break;
+                }
+                if (c < 128) {
+                    const px = file.subarray(at, at + bytes);
+                    for (let k = 0; k <= c; k++)
+                        line.set(px, x + k * bytes);
+                    at += bytes;
+                    x += (c + 1) * bytes;
+                }
+                else {
+                    const n = (257 - c) * bytes;
+                    line.set(file.subarray(at, at + n), x);
+                    at += n;
+                    x += n;
+                }
+            }
+            for (let k = 0; k < repeat && y < height; k++, y++)
+                page.pixels.set(line, y * lineBytes);
+        }
+        pages.push(page);
+    }
+    return pages;
+}

package/dist/connectors/printers/state.d.ts

@@ -18,6 +18,8 @@ export type Printer = {
     name: string;
     model?: string;
     host?: string;
+    port?: number;
+    rp?: string;
     room?: string;
     state?: PrinterStatus;
     stateCode?: number;

package/dist/connectors/spotify/changes.d.ts

@@ -2,8 +2,16 @@ import type { Part } from "../../home.ts";
 import type { SpotifyState, Stall, Track } from "./client.ts";
 /** A stall in a few words: `playback stalled at 1:39 (Soloist issue #5); tried a seek`. */
 export declare function stallText(s: Stall | undefined): string | undefined;
-/** The speaker in one word, to switch on. `offline`: not reached (or no part); `waiting`: running, nobody has picked it. A status Soloist sends beyond its four passes through. */
-export type SpeakerState = "offline" | "connecting" | "waiting" | "idle" | "playing" | "paused" | "buffering" | (string & {});
+/**
+ * Soloist says playing while it is not the account's active device: the music is on another Spotify device (a phone,
+ * another speaker) and this one is silent (live, 2026-11-10). Soloist doesn't say which. Unknown `active` is not elsewhere.
+ */
+export declare const playingElsewhere: (s: SpotifyState | undefined) => boolean;
+/**
+ * The speaker in one word, to switch on. `offline`: not reached (or no part); `waiting`: running, nobody has picked it;
+ * `elsewhere`: the account's music is playing on another Spotify device, not this one. A status Soloist sends beyond its four passes through.
+ */
+export type SpeakerState = "offline" | "connecting" | "waiting" | "elsewhere" | "idle" | "playing" | "paused" | "buffering" | (string & {});
 export declare function speakerState(part: Part<SpotifyState> | undefined): SpeakerState;
 /**
  * A change worth telling someone about, from two reports of the speaker. `own`, on playback events only: it happened while
@@ -24,9 +32,15 @@ export type SpotifyEvent = {
 /**
  * The events between two reports, for `onChange`'s `before` and `after`: `offline` and `online`; `waiting` (signed out) and
  * `picked` (someone picked the speaker); `started` (from idle), `resumed` (from paused), `paused`, `stopped` (to idle), then
- * `track` for a new track, once it has a name, then `stalled` and `recovered` (Soloist issue #5). Buffering counts as playing. No `before`, or one
+ * `track` for a new track, once it has a name, then `stalled` and `recovered` (Soloist issue #5). Buffering counts as playing.
+ * Music on another Spotify device (`playingElsewhere`) is not playing here: it moving away is `stopped`, it arriving is `started`
+ * then `track`, and nothing fires for its tracks meanwhile. No `before`, or one
  * with no state (createHome's placeholder before the first report, as at a restart): nothing, since nothing was seen to change. No volume or queue events: read the state.
  */
 export declare function spotifyChanges(before: Part<SpotifyState> | undefined, after: Part<SpotifyState> | undefined): SpotifyEvent[];
-/** The speaker in a few words: `Kitchen speaker: playing "Song" by Band · 35%`, or `…: waiting for someone to pick it`. */
-export declare function spotifyText(s: SpotifyState): string;
+/**
+ * The speaker in a few words: `Kitchen speaker: playing "Song" by Band · 35%`, `…: waiting for someone to pick it`, or,
+ * for music on another Spotify device, `…: silent · "Song" by Band is playing on another Spotify device` (no volume: it isn't this speaker's playing level).
+ * `on` names where, when the caller knows (`spotifyElsewhere`): `… is playing on Den speaker`.
+ */
+export declare function spotifyText(s: SpotifyState, on?: string[]): string;

package/dist/connectors/spotify/changes.js

@@ -9,6 +9,12 @@ export function stallText(s) {
         : `playback stalled at ${at} (Soloist issue #5)`;
     return s.tried ? `${what}; tried ${s.tried}` : what;
 }
+const PLAYING = new Set(["playing", "buffering"]);
+/**
+ * Soloist says playing while it is not the account's active device: the music is on another Spotify device (a phone,
+ * another speaker) and this one is silent (live, 2026-11-10). Soloist doesn't say which. Unknown `active` is not elsewhere.
+ */
+export const playingElsewhere = (s) => s?.active === false && PLAYING.has(s.status ?? "");
 export function speakerState(part) {
     if (!part || part.status === "disconnected" || part.status === "unavailable")
         return "offline";
@@ -16,13 +22,16 @@ export function speakerState(part) {
         return "connecting";
     if (part.state?.loggedIn === false)
         return "waiting";
+    if (playingElsewhere(part.state))
+        return "elsewhere";
     return part.state?.status ?? "idle"; // signed in, nothing reported yet: nothing is playing
 }
-const PLAYING = new Set(["playing", "buffering"]);
 /**
  * The events between two reports, for `onChange`'s `before` and `after`: `offline` and `online`; `waiting` (signed out) and
  * `picked` (someone picked the speaker); `started` (from idle), `resumed` (from paused), `paused`, `stopped` (to idle), then
- * `track` for a new track, once it has a name, then `stalled` and `recovered` (Soloist issue #5). Buffering counts as playing. No `before`, or one
+ * `track` for a new track, once it has a name, then `stalled` and `recovered` (Soloist issue #5). Buffering counts as playing.
+ * Music on another Spotify device (`playingElsewhere`) is not playing here: it moving away is `stopped`, it arriving is `started`
+ * then `track`, and nothing fires for its tracks meanwhile. No `before`, or one
  * with no state (createHome's placeholder before the first report, as at a restart): nothing, since nothing was seen to change. No volume or queue events: read the state.
  */
 export function spotifyChanges(before, after) {
@@ -45,8 +54,11 @@ export function spotifyChanges(before, after) {
         events.push({ type: "waiting" });
     if (b?.loggedIn === false && a?.loggedIn === true)
         events.push({ type: "picked" });
-    const from = b?.status;
-    const to = a?.status;
+    // What this speaker itself is doing: music on another device is silence here.
+    const here = (s) => (playingElsewhere(s) ? "idle" : s?.status);
+    const from = here(b);
+    // Still inactive after playing elsewhere: a pause or stop there is the other device's, not this one's.
+    const to = playingElsewhere(b) && a?.active === false ? "idle" : here(a);
     const playingNow = to !== undefined && PLAYING.has(to);
     const playingThen = from !== undefined && PLAYING.has(from);
     if (playingNow && !playingThen)
@@ -57,7 +69,11 @@ export function spotifyChanges(before, after) {
         add({ type: "stopped" });
     // Soloist's first report of a new track can have no name yet (seen live): the event waits for it.
     const named = (p) => !!p?.track?.name;
-    if (a?.track && named(a) && (a.track.uri !== b?.track?.uri || !named(b)))
+    const heard = playingElsewhere(b) && playingNow ? undefined : b; // a track that was on another device is new here once it plays here
+    if (a?.track &&
+        named(a) &&
+        !playingElsewhere(a) &&
+        (a.track.uri !== heard?.track?.uri || !named(heard)))
         add({ type: "track", track: a.track });
     if (a?.stalled && !b?.stalled)
         events.push({ type: "stalled", stall: a.stalled });
@@ -68,8 +84,12 @@ export function spotifyChanges(before, after) {
         events.push({ type: "recovered" });
     return events;
 }
-/** The speaker in a few words: `Kitchen speaker: playing "Song" by Band · 35%`, or `…: waiting for someone to pick it`. */
-export function spotifyText(s) {
+/**
+ * The speaker in a few words: `Kitchen speaker: playing "Song" by Band · 35%`, `…: waiting for someone to pick it`, or,
+ * for music on another Spotify device, `…: silent · "Song" by Band is playing on another Spotify device` (no volume: it isn't this speaker's playing level).
+ * `on` names where, when the caller knows (`spotifyElsewhere`): `… is playing on Den speaker`.
+ */
+export function spotifyText(s, on = []) {
     const who = s.deviceName ?? "Soloist";
     if (s.loggedIn === false)
         return `${who}: waiting for someone to pick it`;
@@ -77,6 +97,8 @@ export function spotifyText(s) {
     const what = t
         ? `${t.name ? ` "${t.name}"` : ` ${t.uri}`}${t.artists.length ? ` by ${t.artists.join(", ")}` : ""}`
         : "";
+    if (playingElsewhere(s))
+        return `${who}: silent ·${what || " music"} is playing on ${on.length ? on.join(", ") : "another Spotify device"}`;
     const parts = [
         `${s.status ?? "status unknown"}${what}`,
         s.volume === undefined ? "" : `${s.volume}%`,

package/dist/connectors/spotify/index.d.ts

@@ -5,7 +5,7 @@ import type { Manifest } from "../../manifest.ts";
 import { type SpeakerState } from "./changes.ts";
 import { type SocketFactory, type SpotifyState } from "./client.ts";
 export { positionMs, type PositionAnchor, type SocketFactory, type SocketLike, type SpotifyState, type Stall, toSpotifyUri, type Track, } from "./client.ts";
-export { type SpeakerState, speakerState, type SpotifyEvent, spotifyChanges, spotifyText, } from "./changes.ts";
+export { type SpeakerState, playingElsewhere, speakerState, type SpotifyEvent, spotifyChanges, spotifyText, } from "./changes.ts";
 /** Soloist has no default port (`--ws ADDR:PORT` opens it); this library assumes this one, the port in chota-bot's unit. */
 export declare const DEFAULT_URL = "ws://127.0.0.1:9091";
 /** A Soloist speaker in a home config. No key: Soloist's API key is the daemon's, never the library's. */

package/dist/connectors/spotify/index.js

@@ -6,7 +6,7 @@ import { writeLane } from "../../lane.js";
 import { speakerState, spotifyText, stallText, } from "./changes.js";
 import { commandFrame, fold, Frame, FRAME_TYPES, OPEN, oddities, positionMs, toSpotifyUri, } from "./client.js";
 export { positionMs, toSpotifyUri, } from "./client.js";
-export { speakerState, spotifyChanges, spotifyText, } from "./changes.js";
+export { playingElsewhere, speakerState, spotifyChanges, spotifyText, } from "./changes.js";
 /** Soloist has no default port (`--ws ADDR:PORT` opens it); this library assumes this one, the port in chota-bot's unit. */
 export const DEFAULT_URL = "ws://127.0.0.1:9091";
 /** A Soloist speaker in a home config. No key: Soloist's API key is the daemon's, never the library's. */
@@ -228,6 +228,17 @@ export function spotify(config = {}) {
      * one raised before it is reported can't be told from the start's own jump, so it is lowered too.
      */
     const applyCap = () => {
+        // Lowered, then above the cap again in the same window: Soloist putting its own level back (seen live) or a person.
+        // The note says where it is now, not only that it was lowered.
+        if (capped && capNote && cap !== undefined && state.volume !== undefined) {
+            const base = capNote.replace(/; it is back at \d+$/, "");
+            const note = state.volume > cap + VOLUME_SLACK
+                ? `${base}; it is back at ${state.volume}`
+                : base;
+            if (note !== capNote)
+                ((capNote = note), publish());
+            return;
+        }
         if (cap === undefined ||
             capped ||
             capping ||
@@ -247,7 +258,7 @@ export function spotify(config = {}) {
                 capped = true;
                 if (state.status === "idle")
                     return;
-                capNote = `started at volume ${from}, above maxVolume ${cap}; lowered it (Soloist issue #23)`;
+                capNote = `started at volume ${from}, above maxVolume ${cap}; lowered it to ${cap} (Soloist issue #23)`;
                 note = undefined;
                 return publish();
             }
@@ -651,6 +662,7 @@ export function spotify(config = {}) {
         if (!st ||
             state.aside === "repair" ||
             (state.track?.uri === st.track &&
+                state.active !== false && // moved to another device: no longer this speaker's stall
                 (state.status === "playing" || state.status === "buffering")))
             return;
         const { stalled: _, ...rest } = state;
@@ -678,7 +690,11 @@ export function spotify(config = {}) {
         a.track === b.track &&
         b.atMs - a.atMs >= gap &&
         Math.abs(b.ms - a.ms) < 1000;
-    const playing = () => isOpen() && state.status === "playing" && !state.aside;
+    // Not while inactive: "playing" then is another device's music, and a repair's seek or pause would land on it.
+    const playing = () => isOpen() &&
+        state.status === "playing" &&
+        state.active !== false &&
+        !state.aside;
     /** One look while playing: a fresh position, then frozen, overrun, recovered or fine (Soloist issue #5). */
     const checkStall = async () => {
         if (!playing())
@@ -720,6 +736,7 @@ export function spotify(config = {}) {
         // Still ours to fix: playing this track, stalled, and no duck, interrupt or person in between.
         const ours = () => isOpen() &&
             state.status === "playing" &&
+            state.active !== false &&
             state.track?.uri === track &&
             state.stalled?.track === track &&
             (!state.aside || state.aside === "repair");

package/dist/connectors/up/client.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ConnectorError } from "../../connector.ts";
-/** A failed Up call. `status` 401 means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
+/** A failed Up call. `status` 401 or 403 (`isRejectedKey`) means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
 export declare class UpError extends ConnectorError {
 }
 declare const TransactionResource: z.ZodObject<{

package/dist/connectors/up/client.js

@@ -3,7 +3,7 @@ import { ConnectorError, fetchTimeout, getJson } from "../../connector.js";
 // Up Bank's API v1 (https://developer.up.com.au/, spec github.com/up-banking/api, v1/openapi.json). Field names checked
 // against one live read, 2026-10-16. Every field optional so a change degrades a reading rather than throwing.
 const BASE = "https://api.up.com.au/api/v1";
-/** A failed Up call. `status` 401 means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
+/** A failed Up call. `status` 401 or 403 (`isRejectedKey`) means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
 export class UpError extends ConnectorError {
 }
 const Money = z.looseObject({

package/dist/connectors/up/index.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { asOf, realClock } from "../../clock.js";
-import { errorText } from "../../connector.js";
+import { errorText, isRejectedKey } from "../../connector.js";
 import { envName } from "../../home.js";
 import { poller } from "../../poll.js";
 import { upClient, UpError, } from "./client.js";
@@ -139,7 +139,7 @@ export function up(config) {
                 catch (error) {
                     if (signal.aborted)
                         return; // stopped mid-read: not a failure
-                    if (error instanceof UpError && error.status === 401)
+                    if (isRejectedKey(error))
                         return update({
                             status: "unavailable",
                             reason: "auth",

package/dist/connectors/weather/google.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ConnectorError, fetchTimeout } from "../../connector.js";
+import { ConnectorError, fetchTimeout, isRejectedKey, } from "../../connector.js";
 import { RAIN_INTENSITIES } from "./rain.js";
 import { sunDisagrees } from "./sun.js";
 import { HOURLY_MINUTES, iso, nextPoll, num, RAIN_HORIZON_MINUTES, USER_AGENT, } from "./source.js";
@@ -360,7 +360,7 @@ export function google(options) {
                     ? error
                     : {};
                 const said = `HTTP ${status}${why ? ` ${why}` : ""}`;
-                if (status === 401 || status === 403 || why?.startsWith("API_KEY_"))
+                if (isRejectedKey(error) || why?.startsWith("API_KEY_"))
                     return {
                         stop: `google: the key was rejected (${said})`,
                         stopReason: "auth",

package/dist/devices.d.ts

@@ -25,3 +25,27 @@ export declare const SERVICES: readonly string[];
  * no name of its own (the Daikin, the Enphase gateway) the entry's `name`. A device's own name is never replaced.
  */
 export declare function homeDevices(snapshot: Record<string, Part | undefined>, config?: Pick<HomeConfig, "devices" | "rooms">): HomeDevice[];
+/**
+ * Where the account's Spotify is playing when the Soloist speaker says it is on another device: the names of the Cast
+ * devices and groups playing a track of that name in Spotify. A group is named, not its members. Empty when the music is
+ * on the speaker itself, nothing is playing, or it is on something Cast can't see (a phone, a laptop). Matched by the
+ * track's name, since neither side names the other.
+ */
+export declare function spotifyElsewhere(snapshot: Record<string, Part | undefined>): string[];
+/** A room of the home config with the devices placed in it. `noData`: device connectors the config places here that listed nothing in it (never reached, not set up, or a `hueRoom` the bridge doesn't have), so the room isn't empty, it is unread. Per connector, not per device. */
+export type RoomDevices = {
+    id: string;
+    name: string;
+    floor?: string;
+    devices: HomeDevice[];
+    noData: string[];
+};
+/**
+ * `homeDevices` room by room, in the config's order, for a map of the home. A connector that is down but has read before
+ * still lists its devices, `available: false`; `noData` names one the config places in the room (a device's `room`, or
+ * `hueRoom`) that has nothing to list. `unplaced`: devices with no room, or one the config doesn't have.
+ */
+export declare function byRoom(snapshot: Record<string, Part | undefined>, config: Pick<HomeConfig, "devices" | "rooms">): {
+    rooms: RoomDevices[];
+    unplaced: HomeDevice[];
+};

package/dist/devices.js

@@ -3,7 +3,7 @@ import { daikinHomeDevices, } from "./connectors/daikin/index.js";
 import { enphaseHomeDevices, } from "./connectors/enphase/index.js";
 import { hueHomeDevices } from "./connectors/hue/index.js";
 import { printersHomeDevices, } from "./connectors/printers/index.js";
-import { spotifyHomeDevices, } from "./connectors/spotify/index.js";
+import { playingElsewhere, spotifyHomeDevices, spotifyText, } from "./connectors/spotify/index.js";
 import { IDENTITY, sameId } from "./discover.js";
 import { manifestOf } from "./manifests.js";
 /** Each connector's devices from its part, in the order `home status` lists the connectors. */
@@ -23,7 +23,13 @@ export const SERVICES = ["amber", "up", "weather"];
  * no name of its own (the Daikin, the Enphase gateway) the entry's `name`. A device's own name is never replaced.
  */
 export function homeDevices(snapshot, config) {
-    const all = Object.entries(DEVICES).flatMap(([name, devices]) => devices(snapshot[name]));
+    // Soloist doesn't say where its music went; a Cast device playing that track does, so the speaker's line names it.
+    const on = spotifyElsewhere(snapshot);
+    const all = Object.entries(DEVICES)
+        .flatMap(([name, devices]) => devices(snapshot[name]))
+        .map((d) => d.connector === "spotify" && on.length
+        ? { ...d, text: spotifyText(d.detail, on) }
+        : d);
     if (!config)
         return all;
     const entries = config.devices ?? [];
@@ -59,3 +65,51 @@ export function homeDevices(snapshot, config) {
         return { ...d, name, text, ...(room ? { room } : {}) };
     });
 }
+/**
+ * Where the account's Spotify is playing when the Soloist speaker says it is on another device: the names of the Cast
+ * devices and groups playing a track of that name in Spotify. A group is named, not its members. Empty when the music is
+ * on the speaker itself, nothing is playing, or it is on something Cast can't see (a phone, a laptop). Matched by the
+ * track's name, since neither side names the other.
+ */
+export function spotifyElsewhere(snapshot) {
+    const s = snapshot.spotify?.state;
+    const cast = snapshot.cast?.state;
+    const name = s?.track?.name;
+    if (!playingElsewhere(s) || !name || !cast)
+        return [];
+    return Object.values(cast.devices)
+        .filter((d) => d.status === "connected" &&
+        !d.playingVia && // its group's music: the group is named
+        d.app === "Spotify" &&
+        d.title === name &&
+        (d.playerState === "PLAYING" || d.playerState === "BUFFERING"))
+        .map((d) => d.name);
+}
+/**
+ * `homeDevices` room by room, in the config's order, for a map of the home. A connector that is down but has read before
+ * still lists its devices, `available: false`; `noData` names one the config places in the room (a device's `room`, or
+ * `hueRoom`) that has nothing to list. `unplaced`: devices with no room, or one the config doesn't have.
+ */
+export function byRoom(snapshot, config) {
+    const all = homeDevices(snapshot, config);
+    const ids = new Set((config.rooms ?? []).map((r) => r.id));
+    return {
+        rooms: (config.rooms ?? []).map((r) => {
+            const devices = all.filter((d) => d.room === r.id);
+            const expected = new Set([
+                ...(config.devices ?? [])
+                    .filter((d) => d.room === r.id)
+                    .map((d) => d.connector),
+                ...(r.hueRoom === undefined ? [] : ["hue"]),
+            ]);
+            return {
+                id: r.id,
+                name: r.name,
+                ...(r.floor === undefined ? {} : { floor: r.floor }),
+                devices,
+                noData: [...expected].filter((c) => c in DEVICES && !devices.some((d) => d.connector === c)),
+            };
+        }),
+        unplaced: all.filter((d) => !d.room || !ids.has(d.room)),
+    };
+}

package/dist/discover.js

@@ -82,7 +82,7 @@ function newEntry(f) {
         [IDENTITY[f.connector]]: f.id,
     };
     if (f.connector === "hue")
-        return { ...base, key: "HUE_APPLICATION_KEY", ca: "hue-root-ca.pem" };
+        return { ...base, key: "HUE_APPLICATION_KEY" };
     if (f.connector === "enphase")
         return { ...base, token: "~/.config/home/enphase-token.json" };
     return base;

package/dist/finders-entry.d.ts

@@ -1 +1 @@
-export { FINDERS, fileCache } from "./finders.ts";
+export { FINDERS, fileCache, MissingTool } from "./finders.ts";

package/dist/finders-entry.js

@@ -1,2 +1,2 @@
 // `@khalido/home/finders`: what a Node consumer passes to `loadHome`. The rest of finders.ts is the CLI's.
-export { FINDERS, fileCache } from "./finders.js";
+export { FINDERS, fileCache, MissingTool } from "./finders.js";

package/dist/finders.d.ts

@@ -1,5 +1,6 @@
 import { type AddressCache, type Connector, type Finder, type Found } from "./discover.ts";
 /** The system's mDNS tool is not installed: discovery can't run until it is. */
+/** The discovery tool isn't installed (`dns-sd` on macOS, `avahi-browse` from avahi-utils on Linux): the message names it. */
 export declare class MissingTool extends Error {
 }
 /**
@@ -27,7 +28,7 @@ export declare function mdnsResolve(type: string): Promise<{
 }[]>;
 /** Daikin's `key=value,key=value` answers, percent-decoded. */
 export declare const daikinFields: (text: string) => any;
-/** Broadcast pydaikin's discovery packet (UDP 30000 → 30050) and collect who answers within `ms`. */
+/** Broadcast pydaikin's discovery packet (UDP 30000 → 30050), three times across `ms`, and collect who answers, each unit once. */
 export declare function findDaikins(ms?: number): Promise<{
     ip: string;
     fields: Record<string, string>;

package/dist/finders.js

@@ -13,6 +13,7 @@ import { parseAvahi, parseAvahiBrowse, parseBrowse, parseResolve, } from "./disc
 // does not slow a scan. Without the tool the mDNS finders throw, naming it, rather than "nothing answered".
 // `fileCache` keeps the addresses discovery found in a file between runs, so the next run connects straight away.
 /** The system's mDNS tool is not installed: discovery can't run until it is. */
+/** The discovery tool isn't installed (`dns-sd` on macOS, `avahi-browse` from avahi-utils on Linux): the message names it. */
 export class MissingTool extends Error {
 }
 /**
@@ -94,17 +95,27 @@ function decoded(v) {
         return v;
     }
 }
-/** Broadcast pydaikin's discovery packet (UDP 30000 → 30050) and collect who answers within `ms`. */
+/** Broadcast pydaikin's discovery packet (UDP 30000 → 30050), three times across `ms`, and collect who answers, each unit once. */
 export function findDaikins(ms = 1500) {
     return new Promise((resolve) => {
         const found = [];
         const sock = createSocket({ type: "udp4", reuseAddr: true });
-        sock.on("message", (msg, from) => found.push({ ip: from.address, fields: daikinFields(msg.toString()) }));
-        sock.on("error", () => (sock.close(), resolve(found)));
+        sock.on("message", (msg, from) => {
+            if (!found.some((f) => f.ip === from.address))
+                found.push({ ip: from.address, fields: daikinFields(msg.toString()) });
+        });
+        const asks = [];
+        const done = () => (asks.forEach(clearTimeout),
+            sock.close(),
+            resolve(found));
+        sock.on("error", done);
         sock.bind(30000, () => {
             sock.setBroadcast(true);
-            sock.send("DAIKIN_UDP/common/basic_info", 30050, "255.255.255.255");
-            setTimeout(() => (sock.close(), resolve(found)), ms);
+            // UDP drops packets, more so while mDNS is busy beside it: one ask missed KO's unit in 2 runs of 3 (2026-11-11). Ask three times.
+            const ask = () => sock.send("DAIKIN_UDP/common/basic_info", 30050, "255.255.255.255");
+            ask();
+            asks.push(setTimeout(ask, ms / 3), setTimeout(ask, (2 * ms) / 3));
+            setTimeout(done, ms);
         });
     });
 }