@hashsome/core 0.1.0 → 0.3.0

package/dist/client.js

@@ -4,6 +4,8 @@ import { encodeMessage, parseServerMessage } from './protocol.js';
  * subscriptions, resubscribes and reconnects with backoff. Listeners receive
  * `undefined` until the server has answered, then an entity or `null` (unknown entity).
  */
+/** How long a request waits for the connection to open before it fails, in ms. */
+const WAIT_MS = 10_000;
 export class RemoteClient {
     #options;
     #socket;
@@ -16,6 +18,9 @@ export class RemoteClient {
     #listeners = new Map();
     #pending = new Map();
     #nextId = 1;
+    /** Requests made while the connection was not open yet (opening, or back after a drop): each is
+     * sent when it opens, or given up on after a while. */
+    #waiting = new Set();
     #retry = 0;
     #timer;
     #stopped = true;
@@ -35,6 +40,7 @@ export class RemoteClient {
     close() {
         this.#stopped = true;
         clearTimeout(this.#timer);
+        this.#giveUpWaiting(new Error('Connection closed'));
         this.#socket?.close();
         this.#socket = undefined;
         this.#setLink('closed');
@@ -90,7 +96,7 @@ export class RemoteClient {
             ref,
             query: 'browse',
             args: { ...query },
-        })));
+        }), true));
     }
     async history(ref, query) {
         return (await this.#request((id) => ({
@@ -99,12 +105,83 @@ export class RemoteClient {
             ref,
             query: 'history',
             args: { ...query },
-        })));
+        }), true));
+    }
+    async forecast(ref, query) {
+        return (await this.#request((id) => ({
+            type: 'query',
+            id,
+            ref,
+            query: 'forecast',
+            args: { ...query },
+        }), true));
+    }
+    async logbook(ref, query) {
+        return (await this.#request((id) => ({
+            type: 'query',
+            id,
+            ref,
+            query: 'logbook',
+            args: { ...query },
+        }), true));
+    }
+    async queue(ref, query) {
+        return (await this.#request((id) => ({
+            type: 'query',
+            id,
+            ref,
+            query: 'queue',
+            args: { ...query },
+        }), true));
     }
     callRaw(integration, request) {
         return this.#request((id) => ({ type: 'raw', id, integration, request }));
     }
-    #request(build) {
+    /** Resolves once the connection is open: now if it is, else when it opens. The page asks for things
+     * the moment it appears, which can be before the socket has finished opening, and a request made
+     * then waits for it instead of failing. It fails if the connection does not come within
+     * `WAIT_MS` (or the client was closed), and the caller can ask again later. */
+    #whenOpen() {
+        if (this.#socket?.readyState === 1) {
+            return Promise.resolve();
+        }
+        if (this.#stopped) {
+            return Promise.reject(new Error('Not connected to runtime'));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                open: () => {
+                    clearTimeout(waiter.timer);
+                    resolve();
+                },
+                fail: (error) => {
+                    clearTimeout(waiter.timer);
+                    reject(error);
+                },
+                timer: setTimeout(() => {
+                    this.#waiting.delete(waiter);
+                    reject(new Error('Not connected to runtime'));
+                }, WAIT_MS),
+            };
+            this.#waiting.add(waiter);
+        });
+    }
+    #giveUpWaiting(error) {
+        for (const waiter of Array.from(this.#waiting)) {
+            waiter.fail(error);
+        }
+        this.#waiting.clear();
+    }
+    /** Sends a request and resolves with its answer. A read (`wait`) made before the connection is open
+     * waits for it; a command or a raw request never does, since doing it late, after the person has
+     * seen it fail, would be a surprise. */
+    #request(build, wait = false) {
+        if (!wait || this.#socket?.readyState === 1) {
+            return this.#sendRequest(build);
+        }
+        return this.#whenOpen().then(() => this.#sendRequest(build));
+    }
+    #sendRequest(build) {
         const id = this.#nextId++;
         return new Promise((resolve, reject) => {
             if (this.#socket?.readyState !== 1) {
@@ -136,6 +213,10 @@ export class RemoteClient {
         socket.addEventListener('open', () => {
             this.#retry = 0;
             this.#setLink('open');
+            for (const waiter of Array.from(this.#waiting)) {
+                waiter.open();
+            }
+            this.#waiting.clear();
             for (const ref of this.#listeners.keys()) {
                 this.#send({ type: 'subscribe', ref });
             }

package/dist/integration.d.ts

@@ -1,5 +1,5 @@
 import type { EntityRef } from './entity.ts';
-import type { BrowseQuery, BrowseResult, Entity, HistoryQuery, HistoryResult } from './model/index.ts';
+import type { BrowseQuery, BrowseResult, Entity, ForecastQuery, ForecastResult, HistoryQuery, HistoryResult, LogbookQuery, LogbookResult, QueueQuery, QueueResult } from './model/index.ts';
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
 export type Unsubscribe = () => void;
 /**
@@ -48,6 +48,27 @@ export interface Integration {
      * Arguments come from a browser: validate them.
      */
     history?(entityId: string, query: HistoryQuery): Promise<HistoryResult>;
+    /**
+     * A weather entity's forecast of the asked kind (days, hours, half-days), soonest first. Optional:
+     * only for backends that have forecasts. Resolves with no points when the entity cannot give that
+     * kind, and rejects with a displayable `Error` for an unknown entity. Arguments come from a
+     * browser: validate them.
+     */
+    forecast?(entityId: string, query: ForecastQuery): Promise<ForecastResult>;
+    /**
+     * Recent activity of an entity: what happened to it (turned on, went offline) and who or what
+     * caused it, newest first. Optional: only for backends that keep such a record (Home Assistant's
+     * logbook). Resolves with no entries for an entity with none, and rejects with a displayable
+     * `Error` for an unknown entity. Arguments come from a browser: validate them.
+     */
+    logbook?(entityId: string, query: LogbookQuery): Promise<LogbookResult>;
+    /**
+     * A media player's queue: the tracks that play, in order, starting a little before the current one.
+     * Optional: only for players that report `capabilities.queue`. Resolves with no items for a player
+     * with an empty queue, and rejects with a displayable `Error` for an unknown entity. Arguments come
+     * from a browser: validate them.
+     */
+    queue?(entityId: string, query: QueueQuery): Promise<QueueResult>;
     /**
      * Fetches a file the backend serves for its entities, such as artwork, with the integration's own
      * credentials. `path` is the backend's own path and starts with `/`; it comes from a browser, so

package/dist/local-client.d.ts

@@ -1,7 +1,7 @@
 import type { Client, EntityListener, LinkStatus } from './client.ts';
 import { type EntityRef } from './entity.ts';
 import type { ConnectionStatus, Integration, Unsubscribe } from './integration.ts';
-import type { BrowseQuery, BrowseResult, Entity, HistoryQuery, HistoryResult } from './model/index.ts';
+import type { BrowseQuery, BrowseResult, Entity, ForecastQuery, ForecastResult, HistoryQuery, HistoryResult, LogbookQuery, LogbookResult, QueueQuery, QueueResult } from './model/index.ts';
 /** In-process `Client` over integrations, with no runtime server. Used by the gallery and tests. */
 export declare class LocalClient implements Client {
     #private;
@@ -18,5 +18,8 @@ export declare class LocalClient implements Client {
     command(ref: EntityRef, name: string, args?: Record<string, unknown>): Promise<void>;
     browse(ref: EntityRef, query: BrowseQuery): Promise<BrowseResult>;
     history(ref: EntityRef, query: HistoryQuery): Promise<HistoryResult>;
+    forecast(ref: EntityRef, query: ForecastQuery): Promise<ForecastResult>;
+    logbook(ref: EntityRef, query: LogbookQuery): Promise<LogbookResult>;
+    queue(ref: EntityRef, query: QueueQuery): Promise<QueueResult>;
     callRaw(integration: string, request: Record<string, unknown>): Promise<unknown>;
 }

package/dist/local-client.js

@@ -99,6 +99,39 @@ export class LocalClient {
         }
         return source.history(id, query);
     }
+    forecast(ref, query) {
+        const { integration, id } = parseEntityRef(ref);
+        const source = this.#integrations.get(integration);
+        if (!source) {
+            return Promise.reject(new Error(`Unknown integration "${integration}"`));
+        }
+        if (!source.forecast) {
+            return Promise.reject(new Error(`"${integration}" has no forecasts`));
+        }
+        return source.forecast(id, query);
+    }
+    logbook(ref, query) {
+        const { integration, id } = parseEntityRef(ref);
+        const source = this.#integrations.get(integration);
+        if (!source) {
+            return Promise.reject(new Error(`Unknown integration "${integration}"`));
+        }
+        if (!source.logbook) {
+            return Promise.reject(new Error(`"${integration}" keeps no activity`));
+        }
+        return source.logbook(id, query);
+    }
+    queue(ref, query) {
+        const { integration, id } = parseEntityRef(ref);
+        const source = this.#integrations.get(integration);
+        if (!source) {
+            return Promise.reject(new Error(`Unknown integration "${integration}"`));
+        }
+        if (!source.queue) {
+            return Promise.reject(new Error(`"${integration}" has no queue`));
+        }
+        return source.queue(id, query);
+    }
     callRaw(integration, request) {
         const source = this.#integrations.get(integration);
         if (!source) {

package/dist/mock-forecast.d.ts

@@ -0,0 +1,8 @@
+import type { Entity, ForecastQuery, ForecastResult } from './model/index.ts';
+/**
+ * A made-up but believable forecast for a mock weather entity, so the UI that a real source feeds
+ * has something to show: a spell of weather moving through, warmer afternoons and colder nights
+ * around the entity's current temperature. The same every time for the same entity and moment (`now`
+ * is a parameter so a test can pin it). Anything that is not a weather entity has none.
+ */
+export declare function mockForecast(entity: Entity | undefined, query: ForecastQuery, now?: number): ForecastResult;

package/dist/mock-forecast.js

@@ -0,0 +1,136 @@
+const HOUR = 3_600_000;
+const DAY = 24 * HOUR;
+/** A spell of weather the made-up days run through, so a forecast is not one flat condition. */
+const SPELL = [
+    'sunny',
+    'partlycloudy',
+    'cloudy',
+    'rainy',
+    'pouring',
+    'partlycloudy',
+    'sunny',
+    'sunny',
+    'cloudy',
+    'fog',
+];
+/** How likely rain is under each condition, percent. */
+const RAIN = {
+    cloudy: 15,
+    fog: 10,
+    rainy: 70,
+    pouring: 95,
+    'lightning-rainy': 90,
+    'snowy-rainy': 80,
+};
+/** How much of the sky is cloud under each condition, percent. */
+const CLOUD = {
+    sunny: 4,
+    'clear-night': 4,
+    partlycloudy: 50,
+    cloudy: 90,
+    fog: 100,
+    rainy: 95,
+    pouring: 100,
+    'lightning-rainy': 100,
+};
+const STEPS = { daily: 10, hourly: 48, twice_daily: 14 };
+const round = (value) => Math.round(value * 10) / 10;
+/**
+ * A made-up but believable forecast for a mock weather entity, so the UI that a real source feeds
+ * has something to show: a spell of weather moving through, warmer afternoons and colder nights
+ * around the entity's current temperature. The same every time for the same entity and moment (`now`
+ * is a parameter so a test can pin it). Anything that is not a weather entity has none.
+ */
+export function mockForecast(entity, query, now = Date.now()) {
+    if (entity?.kind !== 'weather') {
+        return { type: query.type, points: [] };
+    }
+    const base = entity.temperature ?? 15;
+    const start = new Date(now);
+    const points = [];
+    // The wind swings round slowly and gusts up with the rain.
+    const wind = (step) => entity.windSpeed === undefined
+        ? {}
+        : {
+            windSpeed: round(entity.windSpeed * (0.7 + 0.6 * Math.abs(Math.sin(step * 0.7)))),
+            windBearing: Math.round(((entity.windBearing ?? 0) + step * 9) % 360),
+        };
+    const spellAt = (step) => SPELL[(step + Math.max(0, SPELL.indexOf(entity.condition))) % SPELL.length];
+    if (query.type === 'hourly') {
+        start.setMinutes(0, 0, 0);
+        for (let i = 0; i < STEPS.hourly; i += 1) {
+            const time = new Date(start.getTime() + i * HOUR);
+            const hours = time.getHours();
+            const condition = spellAt(Math.floor(i / 8));
+            const night = hours < 6 || hours >= 21;
+            points.push({
+                timestamp: time.toISOString(),
+                condition: night && condition === 'sunny' ? 'clear-night' : condition,
+                temperature: round(base + 4 * Math.sin(((hours - 9) / 24) * 2 * Math.PI) - i * 0.05),
+                precipitationProbability: RAIN[condition] ?? 0,
+                ...wind(i),
+            });
+        }
+    }
+    else if (query.type === 'twice_daily') {
+        start.setHours(0, 0, 0, 0);
+        for (let i = 0; i < STEPS.twice_daily; i += 1) {
+            const daytime = i % 2 === 0;
+            const condition = spellAt(Math.floor(i / 2));
+            points.push({
+                timestamp: new Date(start.getTime() + i * 12 * HOUR + (daytime ? 6 * HOUR : 0)).toISOString(),
+                condition: !daytime && condition === 'sunny' ? 'clear-night' : condition,
+                temperature: round(daytime ? base + 4 + Math.sin(i) : base - 4 + Math.sin(i)),
+                precipitationProbability: RAIN[condition] ?? 0,
+                daytime,
+                ...wind(i),
+            });
+        }
+    }
+    else {
+        start.setHours(0, 0, 0, 0);
+        for (let i = 0; i < STEPS.daily; i += 1) {
+            const condition = spellAt(i);
+            const drift = 2 * Math.sin(i * 1.3);
+            points.push({
+                timestamp: new Date(start.getTime() + i * DAY).toISOString(),
+                condition,
+                temperature: round(base + 3 + drift),
+                low: round(base - 5 + drift),
+                precipitationProbability: RAIN[condition] ?? 0,
+                ...(RAIN[condition] ? { precipitation: round((RAIN[condition] ?? 0) / 12) } : {}),
+                ...wind(i),
+            });
+        }
+    }
+    // What else a weather source gives for a step, made up from the step itself: it is more humid when
+    // cold and cloudy, the sun peaks at noon (or at its day's best, for a whole day) and is dimmed by cloud,
+    // and gusts and the feels-like follow the wind.
+    const enrich = (point) => {
+        const cloud = CLOUD[point.condition] ?? 50;
+        const temperature = point.temperature ?? base;
+        const hour = new Date(point.timestamp).getHours();
+        const sun = query.type === 'daily' ? 1 : Math.max(0, Math.sin(((hour - 6) / 12) * Math.PI));
+        const rain = RAIN[point.condition] ?? 0;
+        return {
+            ...point,
+            humidity: Math.min(100, Math.max(20, Math.round(85 - (temperature - 5) * 2 + cloud * 0.1))),
+            cloudCoverage: cloud,
+            uvIndex: point.daytime === false ? 0 : round(sun * 8 * (1 - cloud / 140)),
+            apparentTemperature: round(temperature - 1 - (point.windSpeed ?? 0) * 0.05),
+            pressure: Math.round(1015 - rain * 0.12 + Math.sin(hour / 4)),
+            ...(point.windSpeed !== undefined ? { windGustSpeed: round(point.windSpeed * 1.6) } : {}),
+            ...(rain > 50 && point.precipitation === undefined
+                ? { precipitation: round(rain / 70) }
+                : {}),
+        };
+    };
+    return {
+        type: query.type,
+        points: points.map(enrich),
+        ...(entity.unit ? { unit: entity.unit } : {}),
+        ...(entity.precipitationUnit ? { precipitationUnit: entity.precipitationUnit } : {}),
+        ...(entity.pressureUnit ? { pressureUnit: entity.pressureUnit } : {}),
+        ...(entity.windUnit ? { windUnit: entity.windUnit } : {}),
+    };
+}

package/dist/mock-history.d.ts

@@ -0,0 +1,9 @@
+import type { Entity, HistoryQuery, HistoryResult } from './model/index.ts';
+/**
+ * Made-up but believable history for a numeric mock sensor, so the charts a real backend would fill
+ * have something to show: a daily rhythm (more in the evening), a slower drift over the days and a
+ * little jitter. A reading (a temperature, power) hovers around the sensor's current value; an
+ * `energy` counter (kWh or Wh) answers with how much it grew in each bucket. Nothing else has any.
+ * `now` is a parameter so a test can pin it.
+ */
+export declare function mockHistory(entityId: string, entity: Entity | undefined, query: HistoryQuery, now?: number): HistoryResult;

package/dist/mock-history.js

@@ -0,0 +1,65 @@
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const SPAN = { '1h': HOUR, '1d': DAY, '1w': 7 * DAY, '1m': 30 * DAY };
+const BUCKET = { '5m': 5 * MINUTE, '1h': HOUR, '1d': DAY };
+const DEFAULT_BUCKET = {
+    '1h': '5m',
+    '1d': '5m',
+    '1w': '1h',
+    '1m': '1h',
+};
+/** A number in [0, 1) that is the same for the same text, so a mock device always has the same past. */
+function seed(text) {
+    let hash = 0;
+    for (const char of text) {
+        hash = (hash * 31 + char.codePointAt(0)) % 100_003;
+    }
+    return hash / 100_003;
+}
+const round = (value, digits) => {
+    const factor = 10 ** digits;
+    return Math.round(value * factor) / factor;
+};
+/**
+ * Made-up but believable history for a numeric mock sensor, so the charts a real backend would fill
+ * have something to show: a daily rhythm (more in the evening), a slower drift over the days and a
+ * little jitter. A reading (a temperature, power) hovers around the sensor's current value; an
+ * `energy` counter (kWh or Wh) answers with how much it grew in each bucket. Nothing else has any.
+ * `now` is a parameter so a test can pin it.
+ */
+export function mockHistory(entityId, entity, query, now = Date.now()) {
+    if (entity?.kind !== 'sensor' || entity.numeric === undefined) {
+        return { points: [], kind: 'measurement' };
+    }
+    const total = entity.measurement === 'energy' || entity.unit === 'kWh' || entity.unit === 'Wh';
+    const bucket = BUCKET[query.bucket ?? DEFAULT_BUCKET[query.range]];
+    const count = Math.ceil(SPAN[query.range] / bucket);
+    const end = Math.floor(now / bucket) * bucket;
+    const phase = seed(entityId);
+    // How busy the device is at a time: 0 to 1.
+    const level = (time) => {
+        const hours = (time % DAY) / HOUR;
+        const daily = 0.5 + 0.5 * Math.sin(((hours - 9) / 24) * 2 * Math.PI);
+        const drift = 0.15 * Math.sin((time / DAY) * 1.3 + phase * 6);
+        const jitter = 0.015 * Math.sin((time / bucket) * 1.7 + phase * 9);
+        return Math.min(1, Math.max(0, daily + drift + jitter));
+    };
+    // What a counter grows by in a day: about 0.6 to 1.8 kWh, and the same in Wh.
+    const perDay = (0.6 + 1.2 * phase) * (entity.unit === 'Wh' ? 1000 : 1);
+    const points = [];
+    for (let i = count - 1; i >= 0; i -= 1) {
+        const start = end - i * bucket;
+        points.push({
+            timestamp: new Date(start).toISOString(),
+            value: total
+                ? round((perDay / 24) * (bucket / HOUR) * (0.4 + 1.2 * level(start)), 3)
+                : round(entity.numeric * (0.55 + 0.9 * level(start)), 1),
+        });
+    }
+    return {
+        points,
+        kind: total ? 'total' : 'measurement',
+        ...(entity.unit ? { unit: entity.unit } : {}),
+    };
+}

package/dist/mock-logbook.d.ts

@@ -0,0 +1,8 @@
+import type { Entity, LogbookQuery, LogbookResult } from './model/index.ts';
+/**
+ * Made-up but believable activity for a mock light, switch or heater, so the History section of its
+ * drawer has something to show: it turns on and off through the past days, caused by a person or an
+ * automation, now and then going offline by itself. The same every time for the same entity and
+ * moment (`now` is a parameter so a test can pin it). Anything else has none.
+ */
+export declare function mockLogbook(entityId: string, entity: Entity | undefined, query: LogbookQuery, now?: number): LogbookResult;

package/dist/mock-logbook.js

@@ -0,0 +1,43 @@
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+/** Who the made-up activity is caused by: two people at home, and two automations. */
+const ACTORS = [
+    { actor: 'Dan' },
+    { actor: 'Bedtime', actorKind: 'automation' },
+    { actor: 'Alex' },
+    { actor: 'Sunrise', actorKind: 'automation' },
+    {},
+];
+/** The kinds of entity that switch on and off, and so have activity worth showing. */
+const SWITCHING = new Set(['light', 'switch', 'climate']);
+/**
+ * Made-up but believable activity for a mock light, switch or heater, so the History section of its
+ * drawer has something to show: it turns on and off through the past days, caused by a person or an
+ * automation, now and then going offline by itself. The same every time for the same entity and
+ * moment (`now` is a parameter so a test can pin it). Anything else has none.
+ */
+export function mockLogbook(entityId, entity, query, now = Date.now()) {
+    if (!entity || !SWITCHING.has(entity.kind)) {
+        return { entries: [] };
+    }
+    const limit = Math.max(1, Math.min(query.limit ?? 20, 100));
+    const entries = [];
+    let on = entity.kind === 'light' ? entity.on === true : true;
+    for (let i = 0; i < limit; i += 1) {
+        // Further back and a little irregular, newest first.
+        const at = now - (i + 1) * 3 * HOUR - ((i * 7919) % 50) * MINUTE;
+        const cause = ACTORS[(i + entityId.length) % ACTORS.length];
+        const lost = i % 9 === 8;
+        entries.push({
+            id: `${entityId}@${at}`,
+            message: lost ? 'became unavailable' : on ? 'turned on' : 'turned off',
+            timestamp: new Date(at).toISOString(),
+            change: lost ? 'availability' : on ? 'on' : 'off',
+            ...(lost ? {} : cause),
+        });
+        if (!lost) {
+            on = !on;
+        }
+    }
+    return { entries };
+}

package/dist/mock-queue.d.ts

@@ -0,0 +1,9 @@
+import type { BrowseItem, Entity, QueueQuery, QueueResult } from './model/index.ts';
+/**
+ * A made-up queue for a mock player that has one: the tracks of the mock library, round and round,
+ * with the one the player plays third. It is the same every time, so a test or a screenshot can count on it.
+ * Anything that is not a media player with a queue has none.
+ */
+export declare function mockQueue(entity: Entity | undefined, library: Record<string, {
+    items: BrowseItem[];
+}>, query: QueueQuery): QueueResult;

package/dist/mock-queue.js

@@ -0,0 +1,37 @@
+/** How many tracks the made-up queue has. */
+const TOTAL = 24;
+/** How many tracks are before the current one: a little of what has just played. */
+const BEFORE = 2;
+/**
+ * A made-up queue for a mock player that has one: the tracks of the mock library, round and round,
+ * with the one the player plays third. It is the same every time, so a test or a screenshot can count on it.
+ * Anything that is not a media player with a queue has none.
+ */
+export function mockQueue(entity, library, query) {
+    if (entity?.kind !== 'mediaPlayer' || !entity.capabilities.queue) {
+        return { items: [], total: 0, offset: 0 };
+    }
+    const tracks = [
+        ...new Map(Object.values(library)
+            .flatMap((folder) => folder.items)
+            .filter((item) => item.kind === 'track')
+            .map((item) => [item.id, item])).values(),
+    ];
+    if (tracks.length === 0) {
+        return { items: [], total: 0, offset: 0 };
+    }
+    // The track the player says is playing is the one that plays here, so the two agree.
+    const playing = Math.max(0, tracks.findIndex((track) => track.title === entity.media?.title));
+    const items = Array.from({ length: TOTAL }, (_, index) => {
+        const track = tracks[(playing + index + tracks.length * TOTAL - BEFORE) % tracks.length];
+        return {
+            id: `q${index}-${track.id}`,
+            title: track.title,
+            ...(track.subtitle ? { artist: track.subtitle } : {}),
+            ...(track.artworkUrl ? { artworkUrl: track.artworkUrl } : {}),
+            duration: 170 + ((index * 37) % 90),
+            ...(index === BEFORE ? { current: true } : {}),
+        };
+    });
+    return { items: items.slice(0, query.limit ?? 30), total: TOTAL, offset: 0 };
+}

package/dist/mock.d.ts

@@ -1,5 +1,5 @@
 import { BaseIntegration } from './base-integration.ts';
-import { type ActionEntity, type BrowseItem, type BrowseQuery, type BrowseResult, type ClimateEntity, type EntityInput, type GenericEntity, type LightEntity, type MediaPlayerEntity, type PersonEntity, type SensorEntity, type SwitchEntity, type WeatherEntity } from './model/index.ts';
+import { type ActionEntity, type BrowseItem, type BrowseQuery, type BrowseResult, type ClimateEntity, type EntityInput, type ForecastQuery, type ForecastResult, type GenericEntity, type HistoryQuery, type HistoryResult, type LogbookQuery, type LogbookResult, type QueueQuery, type QueueResult, type LightEntity, type MediaPlayerEntity, type PersonEntity, type SensorEntity, type SwitchEntity, type WeatherEntity } from './model/index.ts';
 type Init<E extends {
     kind: string;
     ref: unknown;
@@ -55,6 +55,14 @@ export declare class MockIntegration extends BaseIntegration {
     set(entityId: string, input: EntityInput): void;
     /** Patches an entity: top-level fields are replaced, `capabilities` and `media` are merged. */
     update(entityId: string, patch: Partial<EntityInput>): void;
+    /** Made-up history for a numeric sensor (see `mockHistory`); empty for anything else. */
+    history(entityId: string, query: HistoryQuery): Promise<HistoryResult>;
+    /** A made-up queue for a player that has one (see `mockQueue`); empty for anything else. */
+    queue(entityId: string, query: QueueQuery): Promise<QueueResult>;
+    /** Made-up activity for a light, switch or heater (see `mockLogbook`); empty for anything else. */
+    logbook(entityId: string, query: LogbookQuery): Promise<LogbookResult>;
+    /** Made-up forecast for a weather entity (see `mockForecast`); empty for anything else. */
+    forecast(entityId: string, query: ForecastQuery): Promise<ForecastResult>;
     browse(entityId: string, query: BrowseQuery): Promise<BrowseResult>;
     command(entityId: string, name: string, args?: Record<string, unknown>): Promise<void>;
 }

package/dist/mock.js

@@ -1,5 +1,9 @@
 import { BaseIntegration } from './base-integration.js';
 import { UnknownEntityError } from './entity.js';
+import { mockForecast } from './mock-forecast.js';
+import { mockHistory } from './mock-history.js';
+import { mockLogbook } from './mock-logbook.js';
+import { mockQueue } from './mock-queue.js';
 import { isCommandOf, } from './model/index.js';
 export function mockMediaPlayer(init = {}) {
     const { capabilities, ...rest } = init;
@@ -19,6 +23,7 @@ export function mockMediaPlayer(init = {}) {
             search: false,
             seek: false,
             shuffle: false,
+            queue: false,
             transfer: false,
             group: false,
             ...capabilities,
@@ -95,6 +100,16 @@ export function mockWeather(init = {}) {
         condition: 'sunny',
         temperature: 20,
         unit: '°C',
+        windSpeed: 14,
+        windBearing: 225,
+        windUnit: 'km/h',
+        uvIndex: 3,
+        cloudCoverage: 40,
+        apparentTemperature: 18,
+        pressure: 1015,
+        pressureUnit: 'hPa',
+        precipitationUnit: 'mm',
+        forecasts: ['daily', 'hourly'],
         ...init,
     };
 }
@@ -152,6 +167,8 @@ export function mockLibrary() {
                 libraryFolder('pl-morning', 'Morning coffee', 'playlist', '24 tracks'),
                 libraryFolder('pl-dinner', 'Dinner party', 'playlist', '41 tracks'),
                 libraryFolder('pl-focus', 'Deep focus', 'playlist', '60 tracks'),
+                // A title far too long for any tile, to see how a layout copes with one.
+                libraryFolder('pl-bass', 'BASS BOOSTED SONGS 2026 🔊 REMIXES 🔊 🔊', 'playlist', 'A playlist with a very, very long name to show how titles are held to their room'),
             ],
         },
         albums: {
@@ -189,6 +206,13 @@ export function mockLibrary() {
                 libraryTrack('t-blank-space', 'Blank Space', 'Taylor Swift'),
             ],
         },
+        'pl-bass': {
+            title: 'BASS BOOSTED SONGS 2026 🔊 REMIXES 🔊 🔊',
+            items: [
+                libraryTrack('t-electric', 'Electric Feel', 'MGMT'),
+                libraryTrack('t-borderline', 'Borderline', 'Tame Impala'),
+            ],
+        },
         'al-1989': {
             title: '1989',
             items: [
@@ -377,6 +401,38 @@ export class MockIntegration extends BaseIntegration {
         }
         this.set(entityId, merged);
     }
+    /** Made-up history for a numeric sensor (see `mockHistory`); empty for anything else. */
+    history(entityId, query) {
+        const entity = this.getEntity(entityId);
+        if (!entity) {
+            return Promise.reject(new UnknownEntityError(this.id, entityId));
+        }
+        return Promise.resolve(mockHistory(entityId, entity, query));
+    }
+    /** A made-up queue for a player that has one (see `mockQueue`); empty for anything else. */
+    queue(entityId, query) {
+        const entity = this.getEntity(entityId);
+        if (!entity) {
+            return Promise.reject(new UnknownEntityError(this.id, entityId));
+        }
+        return Promise.resolve(mockQueue(entity, this.#library, query));
+    }
+    /** Made-up activity for a light, switch or heater (see `mockLogbook`); empty for anything else. */
+    logbook(entityId, query) {
+        const entity = this.getEntity(entityId);
+        if (!entity) {
+            return Promise.reject(new UnknownEntityError(this.id, entityId));
+        }
+        return Promise.resolve(mockLogbook(entityId, entity, query));
+    }
+    /** Made-up forecast for a weather entity (see `mockForecast`); empty for anything else. */
+    forecast(entityId, query) {
+        const entity = this.getEntity(entityId);
+        if (!entity) {
+            return Promise.reject(new UnknownEntityError(this.id, entityId));
+        }
+        return Promise.resolve(mockForecast(entity, query));
+    }
     browse(entityId, query) {
         if (!this.getEntity(entityId)) {
             return Promise.reject(new UnknownEntityError(this.id, entityId));