@khalido/home 0.1.2 → 0.2.0

package/dist/connectors/hue/state.js

@@ -1,3 +1,4 @@
+import { mirekToKelvin, xyToHex } from "./color.js";
 /** A snapshot from one full `get()`. */
 export function snapshotFrom(resources, asOf) {
     return {
@@ -32,7 +33,7 @@ const ofType = (s, type) => Object.values(s.resources).filter((r) => r.type ===
 const groupedLightOf = (s, r) => r.services
     ?.map((x) => s.resources[x.rid])
     .find((x) => x?.type === "grouped_light");
-/** Every light, with on, brightness and reachability. */
+/** Every light, with on, brightness, reachability, and its white temperature and colour where it has them. */
 export function lights(s) {
     const zigbee = ofType(s, "zigbee_connectivity");
     return ofType(s, "light").map((l) => {
@@ -43,9 +44,27 @@ export function lights(s) {
             on: l.on?.on,
             brightness: l.dimming?.brightness,
             reachable: link ? link.status === "connected" : undefined,
+            ...colorOf(l),
         };
     });
 }
+/** A light's temperature and colour fields, only those the bridge reported. */
+function colorOf(l) {
+    const out = {};
+    const ct = l.color_temperature;
+    if (typeof ct?.mirek === "number")
+        out.kelvin = mirekToKelvin(ct.mirek);
+    const { mirek_minimum: min, mirek_maximum: max } = ct?.mirek_schema ?? {};
+    if (min !== undefined && max !== undefined)
+        out.kelvinRange = [mirekToKelvin(max), mirekToKelvin(min)];
+    if (l.color?.xy) {
+        out.xy = l.color.xy;
+        out.hex = xyToHex(l.color.xy);
+    }
+    if (l.color?.gamut)
+        out.gamut = l.color.gamut;
+    return out;
+}
 /** Rooms and zones. A room's children are devices; a zone's are lights. */
 export function groups(s) {
     const all = ofType(s, "light");

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

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { type Clock } from "../../clock.ts";
 import { type Finder } from "../../discover.ts";
-import type { Integration } from "../../home.ts";
+import { type DeviceRecord, type Integration, type Part } from "../../home.ts";
 import type { Manifest } from "../../manifest.ts";
-import { type Printer, type PrintersState } from "./state.ts";
+import { type Printer, type PrinterStatus, type PrintersState } from "./state.ts";
 export { type Marker, type Printer, type PrintersState, type PrinterStatus, printerText, } from "./state.ts";
 /** One printer in a home config. Everything the printer reports about itself (model, markers, state) comes live; `host` and `port` are only where it last answered. */
 export declare const configSchema: z.ZodObject<{
@@ -50,3 +50,7 @@ export declare function printers(config?: PrintersConfig): Integration<PrintersS
 /** Printers sorted by name. */
 export declare const printerList: (s: PrintersState) => Printer[];
 export declare const manifest: Manifest<PrintersState>;
+/** A printer as a home device: `state` is the printer's own (`idle`, `printing`, `stopped`, `offline`); `detail` its `Printer`. */
+export type PrinterHomeDevice = DeviceRecord<"printers", "printer", PrinterStatus, Printer>;
+/** Every printer, by name. One that has stopped answering is not `available`, and keeps its last values. */
+export declare function printersHomeDevices(part: Part<PrintersState> | undefined): PrinterHomeDevice[];

package/dist/connectors/printers/index.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { asOf, realClock } from "../../clock.js";
 import { errorText } from "../../connector.js";
 import { DAY_MS, discover, HOUR, lostDetail, rescanDelay, } from "../../discover.js";
+import { deviceRecords, } from "../../home.js";
 import { poller } from "../../poll.js";
 import { getPrinterAttributes, printerUrl } from "./client.js";
 import { attributesOf } from "./codec.js";
@@ -280,3 +281,25 @@ export const manifest = {
         ];
     },
 };
+/** Every printer, by name. One that has stopped answering is not `available`, and keeps its last values. */
+export function printersHomeDevices(part) {
+    if (!part?.state)
+        return [];
+    return deviceRecords(part, printerList(part.state).map((p) => ({
+        connector: "printers",
+        id: p.uuid,
+        name: p.name,
+        kind: "printer",
+        ...(p.state === undefined ? {} : { available: p.state !== "offline" }),
+        ...(p.state === undefined ? {} : { state: p.state }),
+        // An offline printer's values are from when it last answered, not from this check.
+        ...(p.state === "offline"
+            ? p.lastSeen === undefined
+                ? {}
+                : { asOf: p.lastSeen }
+            : { asOf: p.asOf }),
+        text: printerText(p),
+        ...(p.room ? { room: p.room } : {}),
+        detail: p,
+    })));
+}

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 Front room 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 Front room 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

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { type Clock } from "../../clock.ts";
-import type { Integration } from "../../home.ts";
+import { type DeviceRecord, type Integration, type Part } from "../../home.ts";
 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. */
@@ -92,3 +93,7 @@ export type SpotifyActions = {
  */
 export declare function spotify(config?: SpotifyConfig): Integration<SpotifyState, "spotify"> & SpotifyActions;
 export declare const manifest: Manifest<SpotifyState>;
+/** The Soloist speaker as a home device: `state` is `speakerState`'s word; `detail` its `SpotifyState`. */
+export type SpotifyHomeDevice = DeviceRecord<"spotify", "speaker", SpeakerState, SpotifyState>;
+/** The one speaker, once Soloist has said something. Its name is Soloist's `--device-name`, the one phones show. */
+export declare function spotifyHomeDevices(part: Part<SpotifyState> | undefined): SpotifyHomeDevice[];

package/dist/connectors/spotify/index.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
 import { asOf, realClock } from "../../clock.js";
 import { ConnectorError, errorText } from "../../connector.js";
+import { deviceRecords, } from "../../home.js";
 import { writeLane } from "../../lane.js";
-import { spotifyText, stallText } from "./changes.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. */
@@ -259,6 +260,8 @@ export function spotify(config = {}) {
             capping = false;
             if (error instanceof ConnectorError && error.code === "offline")
                 return; // the status says it
+            if (capUntil !== window)
+                return applyCap(); // a new start while it went: this failure doesn't speak for that one
             capped = true; // refused or unanswered: not again this window
             note = `lowering the volume to ${cap} failed: ${errorText(error)}`;
             publish();
@@ -563,6 +566,9 @@ export function spotify(config = {}) {
                 const no = notPlaying();
                 if (no)
                     return no;
+                // "playing" while inactive is the account playing on another speaker (live, 2026-11-10): a pause would stop that one.
+                if (inactive())
+                    return "it is not the active device, so the music playing is on another speaker";
                 track = state.track?.uri;
                 try {
                     shown = (await actions.pause()).confirmed; // a pause that never shows still runs fn: what interrupts matters more
@@ -645,6 +651,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;
@@ -672,7 +679,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())
@@ -714,6 +725,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");
@@ -812,3 +824,22 @@ export const manifest = {
         ? [spotifyText(state)]
         : [],
 };
+/** The one speaker, once Soloist has said something. Its name is Soloist's `--device-name`, the one phones show. */
+export function spotifyHomeDevices(part) {
+    const s = part?.state;
+    if (!s || (s.loggedIn === undefined && s.status === undefined))
+        return [];
+    return deviceRecords(part, [
+        {
+            connector: "spotify",
+            id: "spotify",
+            name: s.deviceName ?? "Soloist",
+            kind: "speaker",
+            available: true,
+            state: speakerState(part),
+            asOf: s.asOf,
+            text: spotifyText(s),
+            detail: s,
+        },
+    ]);
+}

package/dist/connectors/up/index.js

@@ -142,6 +142,7 @@ export function up(config) {
                     if (error instanceof UpError && error.status === 401)
                         return update({
                             status: "unavailable",
+                            reason: "auth",
                             detail: "Up rejected the token",
                             state: last,
                         });

package/dist/connectors/weather/bom.js

@@ -185,6 +185,7 @@ export function bom(options = {}) {
             if (!options.fetch && base.startsWith("ftp:"))
                 return {
                     stop: "bom: plain fetch cannot read ftp://; pass fetch: ftpFetch() from @khalido/home/weather/ftp",
+                    stopReason: "config",
                     nextAt: Infinity,
                 };
             if (force || at >= obsDue) {

package/dist/connectors/weather/google.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getJson } from "../../connector.js";
+import { ConnectorError, fetchTimeout } 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";
@@ -273,6 +273,28 @@ export function toRain(minutes, fetchedAt) {
  */
 export const MIN_POLL_MINUTES = 15;
 export const CURRENT_MINUTES = 30;
+/**
+ * Why Google refused: the `reason` of its error body's ErrorInfo ("API_KEY_INVALID"), since the status alone doesn't say.
+ * A bad key and a bad latitude are both HTTP 400 INVALID_ARGUMENT; only the key's carries a reason (live, 2026-11-10).
+ */
+async function refusal(res) {
+    try {
+        const body = (await res.json());
+        const reason = body.error?.details?.find((d) => d.reason)?.reason;
+        return typeof reason === "string" ? reason : undefined;
+    }
+    catch {
+        return undefined; // not JSON: the status is all there is
+    }
+}
+/** Google's refusal: the HTTP status, and `why`, the reason its error body gave. */
+class GoogleError extends ConnectorError {
+    why;
+    constructor(message, status, why) {
+        super(message, { status });
+        this.why = why;
+    }
+}
 /**
  * Google Weather as a source: modelled `now`, `forecast` (10 days available, 2 read), `sky` without radiation, and `rain` from the
  * minute forecast (Experimental at Google, so its failure is a `problem` on `rain` and never stops the other slices).
@@ -295,11 +317,20 @@ export function google(options) {
         },
         minPollMinutes: MIN_POLL_MINUTES,
         async read({ place, at, pollMinutes, force, signal, }) {
-            const q = (extra) => `key=${encodeURIComponent(options.key)}&location.latitude=${place.latitude}&location.longitude=${place.longitude}${extra}`;
-            const json = (path) => getJson(fetcher, `${base}/${path}`, {
-                init: { headers: { "user-agent": USER_AGENT } },
-                signal,
-            });
+            const q = (extra) => `location.latitude=${place.latitude}&location.longitude=${place.longitude}${extra}`;
+            // The key goes in a header, never the URL, so no error, log or proxy that shows a URL can show it (all four lookups answered 200 this way, live 2026-11-10).
+            const json = async (path) => {
+                const res = await fetchTimeout(fetcher, `${base}/${path}`, {
+                    headers: {
+                        "user-agent": USER_AGENT,
+                        "x-goog-api-key": options.key,
+                    },
+                }, { signal });
+                if (res.ok)
+                    return res.json();
+                const why = await refusal(res);
+                throw new GoogleError(`HTTP ${res.status}${why ? ` ${why}` : ""} on GET /${path.split("?")[0]}`, res.status, why);
+            };
             // Started first and never throws: a failed minute forecast must not sink the rest.
             const minutes = json(`forecast/minutes:lookup?${q("")}`).then((value) => ({ value }), (error) => ({ error: error }));
             let problem;
@@ -324,10 +355,22 @@ export function google(options) {
                 }
             }
             catch (error) {
-                const status = error.status;
-                if (status === 400 || status === 401 || status === 403)
+                // Only a GoogleError is Google's answer; a timeout or an abort is a DOMException, with fields of its own.
+                const { status, why } = error instanceof GoogleError
+                    ? error
+                    : {};
+                const said = `HTTP ${status}${why ? ` ${why}` : ""}`;
+                if (status === 401 || status === 403 || why?.startsWith("API_KEY_"))
+                    return {
+                        stop: `google: the key was rejected (${said})`,
+                        stopReason: "auth",
+                        nextAt: Infinity,
+                    };
+                // A 400 with a good key is the request itself, and here that is the location: asking again won't change it.
+                if (status === 400)
                     return {
-                        stop: `google: key rejected or request refused (HTTP ${status})`,
+                        stop: `google: the request was refused (${said}); check the latitude and longitude`,
+                        stopReason: "config",
                         nextAt: Infinity,
                     };
                 problem = `google: ${error.message}`; // the old slices stay; the minute forecast below is still used

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

@@ -1,5 +1,5 @@
 import { type Clock } from "../../clock.ts";
-import type { Integration } from "../../home.ts";
+import type { Integration, Reason } from "../../home.ts";
 import { type Manifest } from "../../manifest.ts";
 import { type BlockDef, type DayBlocks } from "./blocks.ts";
 import { type RainSoon } from "./rain.ts";
@@ -38,6 +38,7 @@ export type WeatherState = Slices & {
         read: boolean;
         problem?: string;
         stopped?: string;
+        reason?: Exclude<Reason, "crashed">;
         anomaly?: string;
     }>;
 };

package/dist/connectors/weather/index.js

@@ -66,6 +66,7 @@ export function weather(config) {
                             read: r !== undefined,
                             problem: r?.problem,
                             stopped: r?.stop,
+                            reason: r?.stop ? (r.stopReason ?? "config") : undefined,
                             anomaly: r?.anomaly,
                         },
                     ];
@@ -87,6 +88,12 @@ export function weather(config) {
                     : undefined;
                 update({
                     status,
+                    // Every source has stopped: a rejected key outranks a wrong setting, since it needs a person.
+                    reason: status !== "unavailable"
+                        ? undefined
+                        : Object.values(report).some((r) => r.reason === "auth")
+                            ? "auth"
+                            : "config",
                     detail,
                     anomaly: notes("anomaly"),
                     lastGoodAt,

package/dist/connectors/weather/source.d.ts

@@ -1,3 +1,4 @@
+import type { Reason } from "../../home.ts";
 /** Sent on every request, so each service can see who is calling rather than a runtime's default string. */
 export declare const USER_AGENT = "home (+https://github.com/khalido/home.ts)";
 export type Place = {
@@ -116,6 +117,7 @@ export type SourceReading = Slices & {
     problem?: string;
     anomaly?: string;
     stop?: string;
+    stopReason?: Exclude<Reason, "crashed">;
 };
 /**
  * A weather provider. `owns` names the slices it can fill and how old each may get (by its `at`, beyond one polling

package/dist/devices.d.ts

@@ -0,0 +1,51 @@
+import { type CastHomeDevice, castHomeDevices } from "./connectors/cast/index.ts";
+import { type DaikinHomeDevice, daikinHomeDevices } from "./connectors/daikin/index.ts";
+import { type EnphaseHomeDevice, enphaseHomeDevices } from "./connectors/enphase/index.ts";
+import { type HueHomeDevice, hueHomeDevices } from "./connectors/hue/index.ts";
+import { type PrinterHomeDevice, printersHomeDevices } from "./connectors/printers/index.ts";
+import { type SpotifyHomeDevice, spotifyHomeDevices } from "./connectors/spotify/index.ts";
+import type { HomeConfig } from "./config.ts";
+import type { Part } from "./home.ts";
+/** Any device this library reads. `connector`, then `kind` where a connector has more than one, narrows `detail` and `state`. */
+export type HomeDevice = HueHomeDevice | DaikinHomeDevice | EnphaseHomeDevice | CastHomeDevice | PrinterHomeDevice | SpotifyHomeDevice;
+/** Each connector's devices from its part, in the order `home status` lists the connectors. */
+export declare const DEVICES: {
+    hue: typeof hueHomeDevices;
+    daikin: typeof daikinHomeDevices;
+    enphase: typeof enphaseHomeDevices;
+    cast: typeof castHomeDevices;
+    printers: typeof printersHomeDevices;
+    spotify: typeof spotifyHomeDevices;
+};
+/** Connectors that read a service, not a device: nothing to list. */
+export declare const SERVICES: readonly string[];
+/**
+ * Every device in the snapshot. With the home `config`, a device takes the `room` its entry gives it, a Hue room or zone
+ * (and its lights) the room whose `hueRoom` names it (a light in a room and a zone, the room's), and a device that reports
+ * 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[];
+};