@khalido/home 0.0.0-stage → 0.1.1

package/dist/connectors/cast/writes.js

@@ -0,0 +1,390 @@
+import { errorText } from "../../connector.js";
+import { writeLane } from "../../lane.js";
+import { NS } from "./codec.js";
+import { MediaStatus, MultizoneStatus, ReceiverStatus, } from "./schemas.js";
+import { castKey } from "./state.js";
+// Writes over the sockets `cast()` already holds: volume, mute, stop, and an announcement that plays a clip and puts
+// the device back as it was. Never called by the integration itself; tried on a scripted fake socket, not yet live.
+/** Google's own player for a URL of audio or video. */
+export const DEFAULT_MEDIA_RECEIVER = "CC1AD845";
+/** Each request (a status, a volume, LAUNCH, LOAD, STOP) gets this long to answer. */
+export const ANSWER_MS = 10_000;
+/** How long an announcement waits for its clip to finish, beyond the clip's own length when the device reports it. */
+export const PLAY_MS = 60_000;
+const RECEIVER = "receiver-0";
+/** Level writes, and mute writes, per device or group in any minute; more wait their turn, the newest winning. A guess: Cast publishes no limit. */
+export const VOLUME_PER_MINUTE = 30;
+/** Replies that refuse a request. */
+const REFUSALS = new Set([
+    "LAUNCH_ERROR",
+    "LOAD_FAILED",
+    "LOAD_CANCELLED",
+    "INVALID_REQUEST",
+    "INVALID_PLAYER_STATE",
+    "INVALID_MEDIA_SESSION_ID",
+]);
+const idleApp = (app) => !app || app.isIdleScreen === true;
+function checkLevel(level) {
+    if (!(level >= 0 && level <= 1))
+        throw new RangeError(`volume is 0 to 1, got ${level}`);
+}
+/**
+ * The first value `pick` returns for a payload on `s`. Rejects when `pick` throws, when the socket closes, when `signal`
+ * aborts, or after `ms` (a function is read again each time it would expire, so a deadline can grow).
+ */
+function waitFor(clock, s, ms, what, pick, signal) {
+    return new Promise((resolve, reject) => {
+        const done = new AbortController();
+        const finish = (settle) => done.signal.aborted ||
+            (off(),
+                signal?.removeEventListener("abort", cancel),
+                done.abort(),
+                settle());
+        const cancel = () => finish(() => reject(new Error(`stopped waiting for ${what}`)));
+        const off = s.listen((raw) => {
+            if (raw === undefined)
+                return finish(() => reject(new Error(`the socket closed waiting for ${what}`)));
+            try {
+                const value = pick(raw);
+                if (value !== undefined)
+                    finish(() => resolve(value));
+            }
+            catch (error) {
+                finish(() => reject(error));
+            }
+        });
+        signal?.addEventListener("abort", cancel, { once: true });
+        const start = clock.now();
+        const limit = typeof ms === "number" ? () => ms : ms;
+        void (async () => {
+            for (let left = limit(); left > 0 && !done.signal.aborted; left = start + limit() - clock.now())
+                await clock.sleep(left, done.signal);
+            finish(() => reject(new Error(`no ${what} in ${Math.round(limit() / 1000)} s`)));
+        })();
+    });
+}
+/** Send a request and take its reply by requestId; a refusal rejects, naming it. */
+function request(clock, s, namespace, destination, payload, id = s.nextId()) {
+    const reply = waitFor(clock, s, ANSWER_MS, `answer to ${payload.type}`, (raw) => {
+        if (raw.requestId !== id)
+            return undefined;
+        if (typeof raw.type === "string" && REFUSALS.has(raw.type))
+            throw new Error(`${payload.type} refused: ${raw.type}${typeof raw.reason === "string" ? ` (${raw.reason})` : ""}`);
+        return raw;
+    });
+    s.send(namespace, destination, { ...payload, requestId: id });
+    return reply;
+}
+/** Writes over the integration's sockets. */
+export function castActions(ctx) {
+    const { clock } = ctx;
+    const find = (target) => {
+        const all = Object.values(ctx.devices());
+        const d = all.find((x) => x.id === castKey(target)) ??
+            all.find((x) => x.name.toLowerCase() === target.toLowerCase());
+        if (!d)
+            throw new Error(`no Cast device or group "${target}"; have: ${all
+                .map((x) => x.name)
+                .sort()
+                .join(", ") || "none"}`);
+        return d;
+    };
+    const live = (d) => {
+        const s = ctx.session(d.id);
+        if (!s)
+            throw new Error(`${d.name} is not connected${d.detail ? ` (${d.detail})` : ""}`);
+        return s;
+    };
+    /** A receiver request whose reply is a receiver status (GET_STATUS, SET_VOLUME, STOP). */
+    const receiver = async (s, payload = { type: "GET_STATUS" }) => {
+        const r = ReceiverStatus.safeParse(await request(clock, s, NS.receiver, RECEIVER, payload));
+        if (!r.success)
+            throw new Error(`an answer to ${payload.type} that is not a receiver status`);
+        return r.data.status ?? {};
+    };
+    /** A group's socket at the address discovery gives now: a group lives on its leader, which can move. */
+    const regroup = async (d) => {
+        await ctx.discover();
+        const now = ctx.devices()[d.id];
+        const s = ctx.session(d.id);
+        if (s && now && (s.host !== now.host || s.port !== now.port))
+            s.end("the group's leader moved");
+        return ctx.connected(d.id, ANSWER_MS);
+    };
+    /** What the Default Media Receiver is playing on `transport`, enough to load it again where it was. */
+    const playing = async (s, transport) => {
+        s.connect(transport);
+        const r = MediaStatus.safeParse(await request(clock, s, NS.media, transport, { type: "GET_STATUS" }));
+        const m = r.success ? r.data.status?.[0] : undefined;
+        return m?.media?.contentId
+            ? {
+                media: m.media,
+                currentTime: m.currentTime ?? 0,
+                autoplay: m.playerState !== "PAUSED",
+            }
+            : undefined;
+    };
+    /** Each member's volume and mute, from the group's multizone status. */
+    const memberLevels = async (s) => {
+        const r = MultizoneStatus.safeParse(await request(clock, s, NS.multizone, RECEIVER, { type: "GET_STATUS" }));
+        if (!r.success)
+            throw new Error("an answer to the group's multizone status that is not one");
+        return (r.data.status?.devices ?? []).flatMap((m) => {
+            if (!m.deviceId)
+                return [];
+            const id = castKey(m.deviceId);
+            return [
+                {
+                    id,
+                    name: ctx.devices()[id]?.name ?? m.name ?? m.deviceId,
+                    level: m.volume?.level,
+                    muted: m.volume?.muted,
+                },
+            ];
+        });
+    };
+    /** LAUNCH the Default Media Receiver and wait for a receiver status that shows it running with a transport. */
+    const launch = (s) => {
+        const id = s.nextId();
+        const app = waitFor(clock, s, ANSWER_MS, "Default Media Receiver", (raw) => {
+            if (raw.requestId === id &&
+                typeof raw.type === "string" &&
+                REFUSALS.has(raw.type))
+                throw new Error(`LAUNCH refused: ${raw.type}${typeof raw.reason === "string" ? ` (${raw.reason})` : ""}`);
+            const r = ReceiverStatus.safeParse(raw);
+            return r.success
+                ? r.data.status?.applications?.find((a) => a.appId === DEFAULT_MEDIA_RECEIVER && a.transportId)
+                : undefined;
+        });
+        s.send(NS.receiver, RECEIVER, {
+            type: "LAUNCH",
+            appId: DEFAULT_MEDIA_RECEIVER,
+            requestId: id,
+        });
+        return app;
+    };
+    /**
+     * LOAD the clip and wait until its media session goes IDLE: true when FINISHED, an error for any other reason. The media
+     * session comes from LOAD's own reply, read in the same listener, so an IDLE from before the LOAD never counts.
+     */
+    const play = async (s, transport, media, timeoutMs) => {
+        const loadId = s.nextId();
+        let session;
+        let durationS = 0;
+        const cancel = new AbortController();
+        const finished = waitFor(clock, s, () => timeoutMs ?? PLAY_MS + durationS * 1000, "end of the clip", (raw) => {
+            const r = MediaStatus.safeParse(raw);
+            if (!r.success)
+                return undefined;
+            if (raw.requestId === loadId)
+                session = r.data.status?.[0]?.mediaSessionId ?? "any";
+            if (session === undefined)
+                return undefined;
+            for (const m of r.data.status ?? []) {
+                if (session !== "any" &&
+                    m.mediaSessionId !== undefined &&
+                    m.mediaSessionId !== session)
+                    continue;
+                if (typeof m.media?.duration === "number")
+                    durationS = m.media.duration;
+                if (m.playerState !== "IDLE" || !m.idleReason)
+                    continue;
+                if (m.idleReason === "FINISHED")
+                    return true;
+                throw new Error(`the clip stopped: ${m.idleReason}`);
+            }
+            return undefined;
+        }, cancel.signal);
+        finished.catch(() => { }); // awaited below; until then a cancel must not surface as unhandled
+        try {
+            await request(clock, s, NS.media, transport, { type: "LOAD", media, autoplay: true }, loadId);
+        }
+        catch (error) {
+            cancel.abort();
+            throw error;
+        }
+        return finished;
+    };
+    // A lane per device, so a speaker that stopped answering holds up only itself. Level and mute are separate slots:
+    // a SET_VOLUME carries one or the other, never both.
+    const lanes = new Map();
+    const setVolume = (target, volume) => {
+        const id = find(target).id;
+        if (!lanes.has(id))
+            lanes.set(id, writeLane({ gapMs: 0, perMinute: VOLUME_PER_MINUTE, clock }));
+        return lanes
+            .get(id)
+            .send("level" in volume ? "level" : "muted", volume, (v) => receiver(live(find(target)), { type: "SET_VOLUME", volume: v }));
+    };
+    return {
+        async setVolume(target, level) {
+            checkLevel(level);
+            await setVolume(target, { level });
+        },
+        async setMuted(target, muted) {
+            await setVolume(target, { muted });
+        },
+        async stop(target) {
+            const s = live(find(target));
+            const app = (await receiver(s)).applications?.[0];
+            if (app && !app.isIdleScreen)
+                await receiver(s, {
+                    type: "STOP",
+                    ...(app.sessionId ? { sessionId: app.sessionId } : {}),
+                });
+        },
+        /**
+         * Read the target's state, set the volume if asked and unmute a muted target, launch the Default Media Receiver, play the clip to its end, then
+         * put back what it can, always: what the Default Media Receiver was playing is loaded again where it was, an idle
+         * device gets STOP, then the volume (a group's, member by member through each member's own socket). Another app
+         * (Spotify, YouTube) is interrupted and cannot be resumed from here; the result says so. Throws only before anything changed.
+         */
+        async announce(target, clip, options = {}) {
+            if (options.volume !== undefined)
+                checkLevel(options.volume);
+            if (!("url" in clip) && !ctx.serve)
+                throw new Error("a clip of bytes needs serve: serveClip from @khalido/home/cast/serve");
+            let d = find(target);
+            const s = d.kind === "group" ? await regroup(d) : live(d);
+            d = ctx.devices()[d.id] ?? d; // a group's host as discovery gives it now, for serving the clip on its network
+            const before = await receiver(s);
+            const prior = before.applications?.[0];
+            const priorMedia = prior?.appId === DEFAULT_MEDIA_RECEIVER && prior.transportId
+                ? await playing(s, prior.transportId)
+                : undefined;
+            const unmute = before.volume?.muted === true; // a muted target would play the clip silently
+            const members = d.kind === "group" && (options.volume !== undefined || unmute)
+                ? await memberLevels(s)
+                : [];
+            const result = {
+                played: false,
+                restored: [],
+                notRestored: [],
+            };
+            const serving = new AbortController();
+            let served;
+            let volumeSet = false;
+            let launched = false;
+            let ours;
+            try {
+                let url;
+                if ("url" in clip)
+                    url = clip.url;
+                else
+                    ({ url } = served = await ctx.serve(clip.bytes, clip.type, {
+                        host: d.host,
+                        signal: serving.signal,
+                    }));
+                // Level and mute as two requests: Google's receiver docs take one or the other in a SET_VOLUME, not both.
+                if (options.volume !== undefined || unmute)
+                    volumeSet = true;
+                if (options.volume !== undefined)
+                    await receiver(s, {
+                        type: "SET_VOLUME",
+                        volume: { level: options.volume },
+                    });
+                if (unmute)
+                    await receiver(s, { type: "SET_VOLUME", volume: { muted: false } });
+                launched = true;
+                ours = await launch(s);
+                s.connect(ours.transportId);
+                result.played = await play(s, ours.transportId, {
+                    contentId: url,
+                    contentType: clip.type ?? "audio/mpeg",
+                    streamType: "BUFFERED",
+                }, options.timeoutMs);
+            }
+            catch (error) {
+                result.why = errorText(error);
+            }
+            finally {
+                serving.abort();
+                served?.close();
+                if (launched)
+                    await restoreApp();
+                if (volumeSet)
+                    await restoreVolume();
+            }
+            return result;
+            async function restoreApp() {
+                try {
+                    // A LAUNCH that timed out may still have started: look before deciding nothing of ours runs.
+                    const now = ours ??
+                        (await receiver(s)).applications?.find((a) => a.appId === DEFAULT_MEDIA_RECEIVER && a.transportId);
+                    if (!now)
+                        return;
+                    if (priorMedia) {
+                        s.connect(now.transportId);
+                        await request(clock, s, NS.media, now.transportId, {
+                            type: "LOAD",
+                            ...priorMedia,
+                        });
+                        result.restored.push(`${d.name}: what was playing`);
+                        return;
+                    }
+                    await receiver(s, {
+                        type: "STOP",
+                        ...(now.sessionId ? { sessionId: now.sessionId } : {}),
+                    });
+                    if (idleApp(prior) || prior?.appId === DEFAULT_MEDIA_RECEIVER)
+                        result.restored.push(`${d.name}: idle`);
+                    else
+                        result.notRestored.push({
+                            name: d.name,
+                            why: `${prior?.displayName ?? prior?.appId ?? "an app"} was interrupted and cannot be resumed from here`,
+                        });
+                }
+                catch (error) {
+                    result.notRestored.push({
+                        name: d.name,
+                        why: `${priorMedia ? "what was playing" : "idle"} not restored: ${errorText(error)}`,
+                    });
+                }
+            }
+            async function restoreVolume() {
+                const each = d.kind === "group"
+                    ? members
+                    : [
+                        {
+                            id: d.id,
+                            name: d.name,
+                            level: before.volume?.level,
+                            muted: before.volume?.muted,
+                        },
+                    ];
+                for (const m of each) {
+                    const ms = m.id === d.id ? s : ctx.session(m.id);
+                    if (m.level === undefined)
+                        result.notRestored.push({
+                            name: m.name,
+                            why: "its volume before was not reported",
+                        });
+                    else if (!ms)
+                        result.notRestored.push({
+                            name: m.name,
+                            why: "not connected, so its volume stays as the announcement set it",
+                        });
+                    else
+                        try {
+                            await receiver(ms, {
+                                type: "SET_VOLUME",
+                                volume: { level: m.level },
+                            });
+                            if (m.muted)
+                                await receiver(ms, {
+                                    type: "SET_VOLUME",
+                                    volume: { muted: true },
+                                });
+                            result.restored.push(`${m.name}: volume${m.muted ? ", muted" : ""}`);
+                        }
+                        catch (error) {
+                            result.notRestored.push({
+                                name: m.name,
+                                why: `volume not restored: ${errorText(error)}`,
+                            });
+                        }
+                }
+            }
+        },
+    };
+}

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import type { Clock } from "../../clock.ts";
+import { ConnectorError } from "../../connector.ts";
+/** A failed Daikin call. `status` is the HTTP status, or the dsiot `rsc` when HTTP succeeded. */
+export declare class DaikinError extends ConnectorError {
+}
+export type Mode = "auto" | "cool" | "heat" | "fan" | "dry";
+export type Fan = "1" | "2" | "3" | "4" | "5" | "auto" | "quiet";
+/** The AC now. Temperatures in °C as the unit reports them. */
+export type DaikinState = {
+    on?: boolean;
+    mode?: Mode;
+    targetC?: number;
+    roomC?: number;
+    humidity?: number;
+    fan?: Fan;
+    outsideC?: number;
+    anomaly?: string;
+};
+type Node = {
+    pn?: string;
+    pv?: unknown;
+    pch?: Node[];
+};
+declare const Node: z.ZodType<Node>;
+/** Little-endian hex to an integer, two's complement when `signed`: "2700" → 39, "EEFF" → -18. */
+export declare function hexLE(hex: string, signed?: boolean): number | undefined;
+/** Map the indoor and outdoor `dgc_status` trees to a state. Unknown codes go to `anomaly`, never to a guess. */
+export declare function toState(response: unknown): DaikinState;
+/** A multireq body that writes one or more `e_1002` fields of the indoor unit (op 3), merged into one tree. */
+export type WriteRequest = {
+    requests: {
+        op: 3;
+        to: string;
+        pc: Node;
+    }[];
+};
+/** Two writes as one, field by field, the newer value winning: `setMode("cool")` then `setPower(false)` sends mode cool, power off. */
+export declare function mergeWrites(older: WriteRequest, newer: WriteRequest): WriteRequest;
+/** Writes to the unit at most this often, and at most `WRITE_PER_MINUTE` a minute; a guess, the BRP084's limits are unpublished. */
+export declare const WRITE_GAP_MS = 1000;
+export declare const WRITE_PER_MINUTE = 20;
+/** Turn the unit on or off. */
+export declare const setPower: (on: boolean) => WriteRequest;
+/** Select a mode and turn the unit on, as pydaikin and the Alira integration both do. */
+export declare const setMode: (mode: Mode) => WriteRequest;
+/** Set the setpoint of `mode` (usually the current one), one byte of °C × 2. Throws off the unit's range or 0.5 steps; never rounds. */
+export declare function setTarget(c: number, mode: Mode): WriteRequest;
+/** Set the fan speed of `mode` (usually the current one). */
+export declare function setFan(fan: Fan, mode: Mode): WriteRequest;
+/** A client for one unit. Reads are op 2; `write` sends a body built by setPower, setMode, setTarget or setFan. */
+export declare function daikinClient(options: {
+    host: string;
+    fetch: typeof fetch;
+    clock?: Clock;
+}): {
+    /** The indoor and outdoor status in one request. A failed outdoor read leaves `outsideC` empty. */
+    read(signal?: AbortSignal): Promise<DaikinState>;
+    /**
+     * Send a write. Only when KO asks: this changes the AC. Needs an answer for the indoor unit below 4000 (success codes
+     * unconfirmed; re-read to be sure). Writes waiting their turn merge (`mergeWrites`) and resolve with the send that carried them.
+     */
+    write(request: WriteRequest): Promise<void>;
+};
+export {};

package/dist/connectors/daikin/client.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+import { ConnectorError, getJson } from "../../connector.js";
+import { writeLane } from "../../lane.js";
+// Daikin's JSON dsiot API (the BRP084 family): POST /dsiot/multireq, plain HTTP, no key. Field paths and value
+// maps are protocol facts from pydaikin (GPL-3.0, read only; see README.md), checked against KO's unit 2026-10-13.
+/** A failed Daikin call. `status` is the HTTP status, or the dsiot `rsc` when HTTP succeeded. */
+export class DaikinError extends ConnectorError {
+}
+const Node = z.looseObject({
+    pn: z.string().optional(),
+    pv: z.unknown().optional(),
+    get pch() {
+        return z.array(Node).optional();
+    },
+});
+const Multi = z.looseObject({
+    responses: z.array(z.looseObject({
+        fr: z.string().optional(),
+        rsc: z.number().optional(),
+        pc: Node.optional(),
+    })),
+});
+const INDOOR = "/dsiot/edge/adr_0100.dgc_status";
+const OUTDOOR = "/dsiot/edge/adr_0200.dgc_status";
+const MODES = {
+    "0000": "fan",
+    "0100": "heat",
+    "0200": "cool",
+    "0300": "auto",
+    "0500": "dry",
+};
+const FANS = {
+    "0300": "1",
+    "0400": "2",
+    "0500": "3",
+    "0600": "4",
+    "0700": "5",
+    "0A00": "auto",
+    "0B00": "quiet",
+};
+/** Each mode keeps its own setpoint and fan speed under `e_3001`. */
+const TARGET = {
+    cool: "p_02",
+    heat: "p_03",
+    auto: "p_1D",
+};
+const FAN = {
+    cool: "p_09",
+    heat: "p_0A",
+    auto: "p_26",
+    fan: "p_28",
+};
+/** The setpoint range per mode, from the unit's own `md.mi`/`md.mx` (KO's unit, 2026-10-13). */
+const TARGET_RANGE = {
+    cool: [18, 32],
+    heat: [10, 30],
+    auto: [18, 30],
+};
+/** Little-endian hex to an integer, two's complement when `signed`: "2700" → 39, "EEFF" → -18. */
+export function hexLE(hex, signed = false) {
+    if (!/^(?:[0-9a-f]{2})+$/i.test(hex))
+        return undefined;
+    const bytes = hex.match(/../g).reverse().join("");
+    const n = Number.parseInt(bytes, 16);
+    return signed && n >= 2 ** (hex.length * 4 - 1)
+        ? n - 2 ** (hex.length * 4)
+        : n;
+}
+/** The `pv` at a path of `pn` names under one response's tree, by name (never by position). */
+function value(m, fr, path) {
+    let node = m.responses.find((r) => r.fr === fr)?.pc;
+    for (const pn of path)
+        node = node?.pch?.find((c) => c.pn === pn);
+    return typeof node?.pv === "string" ? node.pv : undefined;
+}
+/** Map the indoor and outdoor `dgc_status` trees to a state. Unknown codes go to `anomaly`, never to a guess. */
+export function toState(response) {
+    const m = Multi.parse(response);
+    const odd = [];
+    const indoor = (...path) => value(m, INDOOR, ["e_1002", ...path]);
+    const code = (map, hex, what) => {
+        if (hex !== undefined && !(hex in map))
+            odd.push(`unknown ${what} code ${hex}`);
+        return hex === undefined ? undefined : map[hex];
+    };
+    const temp = (hex, divisor, what) => {
+        if (hex === undefined)
+            return undefined;
+        const n = hexLE(hex, true);
+        if (n === undefined)
+            odd.push(`${what} is not hex: ${hex}`);
+        return n === undefined ? undefined : n / divisor;
+    };
+    const power = indoor("e_A002", "p_01");
+    if (power !== undefined && power !== "00" && power !== "01")
+        odd.push(`unknown power code ${power}`);
+    const mode = code(MODES, indoor("e_3001", "p_01"), "mode");
+    const target = mode && TARGET[mode];
+    const fan = mode && FAN[mode];
+    const humidityHex = indoor("e_A00B", "p_02");
+    const humidity = humidityHex === undefined ? undefined : hexLE(humidityHex);
+    if (humidityHex !== undefined && humidity === undefined)
+        odd.push(`humidity is not hex: ${humidityHex}`);
+    return {
+        on: power === "01" ? true : power === "00" ? false : undefined,
+        mode,
+        targetC: target ? temp(indoor("e_3001", target), 2, "target") : undefined,
+        roomC: temp(indoor("e_A00B", "p_01"), 1, "room temperature"),
+        humidity,
+        fan: fan ? code(FANS, indoor("e_3001", fan), "fan") : undefined,
+        outsideC: temp(value(m, OUTDOOR, ["e_1003", "e_A00D", "p_01"]), 2, "outside temperature"),
+        anomaly: odd.length ? odd.join("; ") : undefined,
+    };
+}
+const write = (fields) => ({
+    requests: [
+        {
+            op: 3,
+            to: INDOOR,
+            pc: {
+                pn: "dgc_status",
+                pch: [
+                    {
+                        pn: "e_1002",
+                        pch: fields.map(([e, pn, pv]) => ({ pn: e, pch: [{ pn, pv }] })),
+                    },
+                ],
+            },
+        },
+    ],
+});
+const fields = (r) => r.requests.flatMap((q) => (q.pc.pch ?? []).flatMap((e1002) => (e1002.pch ?? []).flatMap((e) => (e.pch ?? []).map((f) => [
+    e.pn,
+    f.pn,
+    String(f.pv),
+]))));
+/** Two writes as one, field by field, the newer value winning: `setMode("cool")` then `setPower(false)` sends mode cool, power off. */
+export function mergeWrites(older, newer) {
+    const merged = new Map(fields(older).map((f) => [`${f[0]}/${f[1]}`, f]));
+    for (const f of fields(newer))
+        merged.set(`${f[0]}/${f[1]}`, f);
+    return write([...merged.values()]);
+}
+/** Writes to the unit at most this often, and at most `WRITE_PER_MINUTE` a minute; a guess, the BRP084's limits are unpublished. */
+export const WRITE_GAP_MS = 1000;
+export const WRITE_PER_MINUTE = 20;
+const key = (map, v) => Object.keys(map).find((k) => map[k] === v);
+/** Turn the unit on or off. */
+export const setPower = (on) => write([["e_A002", "p_01", on ? "01" : "00"]]);
+/** Select a mode and turn the unit on, as pydaikin and the Alira integration both do. */
+export const setMode = (mode) => write([
+    ["e_A002", "p_01", "01"],
+    ["e_3001", "p_01", key(MODES, mode)],
+]);
+/** Set the setpoint of `mode` (usually the current one), one byte of °C × 2. Throws off the unit's range or 0.5 steps; never rounds. */
+export function setTarget(c, mode) {
+    const range = TARGET_RANGE[mode];
+    if (!range)
+        throw new DaikinError(`${mode} mode has no setpoint`);
+    if (!Number.isInteger(c * 2) || c < range[0] || c > range[1])
+        throw new DaikinError(`${c} °C is not a ${mode} setpoint (${range[0]}–${range[1]} in 0.5 steps)`);
+    return write([
+        [
+            "e_3001",
+            TARGET[mode],
+            (c * 2).toString(16).toUpperCase().padStart(2, "0"),
+        ],
+    ]);
+}
+/** Set the fan speed of `mode` (usually the current one). */
+export function setFan(fan, mode) {
+    if (!FAN[mode])
+        throw new DaikinError(`${mode} mode has no fan speed`);
+    return write([["e_3001", FAN[mode], key(FANS, fan)]]);
+}
+/** A client for one unit. Reads are op 2; `write` sends a body built by setPower, setMode, setTarget or setFan. */
+export function daikinClient(options) {
+    const lane = writeLane({
+        gapMs: WRITE_GAP_MS,
+        perMinute: WRITE_PER_MINUTE,
+        clock: options.clock,
+    });
+    const multireq = (body, signal) => getJson(options.fetch, `http://${options.host}/dsiot/multireq`, {
+        init: {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        },
+        signal,
+        schema: Multi,
+        error: DaikinError,
+    });
+    return {
+        /** The indoor and outdoor status in one request. A failed outdoor read leaves `outsideC` empty. */
+        async read(signal) {
+            const m = await multireq({
+                requests: [INDOOR, OUTDOOR].map((to) => ({
+                    op: 2,
+                    to: `${to}?filter=pv,pt,md`,
+                })),
+            }, signal);
+            const indoor = m.responses.find((r) => r.fr === INDOOR);
+            if (indoor?.rsc !== 2000)
+                throw new DaikinError(`no indoor status (rsc ${indoor?.rsc})`, {
+                    status: indoor?.rsc,
+                });
+            return toState(m);
+        },
+        /**
+         * Send a write. Only when KO asks: this changes the AC. Needs an answer for the indoor unit below 4000 (success codes
+         * unconfirmed; re-read to be sure). Writes waiting their turn merge (`mergeWrites`) and resolve with the send that carried them.
+         */
+        write(request) {
+            return lane.send("unit", request, async (r) => {
+                const answer = (await multireq(r)).responses.find((x) => x.fr === INDOOR);
+                if (!answer || answer.rsc === undefined || answer.rsc >= 4000)
+                    throw new DaikinError(`no accepted answer from the indoor unit (rsc ${answer?.rsc})`, { status: answer?.rsc });
+            }, mergeWrites);
+        },
+    };
+}