uc-config 0.1.0

package/dist/client.js

@@ -0,0 +1,182 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isObject } from "./util.js";
+import { localFetch } from "./transport.js";
+export class ApiError extends Error {
+    status;
+    method;
+    path;
+    constructor(status, method, path) {
+        super(`${method} ${path}: HTTP ${status}`);
+        this.status = status;
+        this.method = method;
+        this.path = path;
+    }
+}
+export class CoreClient {
+    token;
+    transport;
+    timeout;
+    base;
+    constructor(host, token, transport = localFetch, timeout = 15000) {
+        this.token = token;
+        this.transport = transport;
+        this.timeout = timeout;
+        this.base = new URL(host.includes("://") ? host : `http://${host}`);
+        if (!["http:", "https:"].includes(this.base.protocol) ||
+            this.base.username ||
+            this.base.password ||
+            this.base.search ||
+            this.base.hash ||
+            !["/", "/api", "/api/"].includes(this.base.pathname))
+            throw new Error("Host must be an HTTP(S) remote origin, optionally ending in /api");
+        this.base.pathname = "/api/";
+    }
+    async request(method, path, body, extra) {
+        if (!path.startsWith("/") || path.startsWith("//") || path.includes(".."))
+            throw new Error("Invalid API path");
+        const url = new URL(path.slice(1), this.base);
+        if (url.origin !== this.base.origin || !url.pathname.startsWith("/api/"))
+            throw new Error("Invalid API origin");
+        const headers = {
+            Accept: "application/json",
+            ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+            ...extra,
+        };
+        const multipart = body instanceof FormData;
+        if (body !== undefined && !multipart)
+            headers["Content-Type"] = "application/json";
+        let response;
+        try {
+            response = await this.transport(url, {
+                method,
+                headers,
+                body: body === undefined
+                    ? undefined
+                    : multipart
+                        ? body
+                        : JSON.stringify(body),
+                signal: AbortSignal.timeout(multipart ? 180000 : this.timeout),
+                redirect: "error",
+            });
+        }
+        catch {
+            throw new Error(`${method} ${path}: transport failed or timed out${method === "GET" ? "" : " (write outcome may be uncertain; inspect journal before retrying)"}`);
+        }
+        if (!response.ok)
+            throw new ApiError(response.status, method, path);
+        const text = await response.text();
+        let data;
+        try {
+            data = text ? JSON.parse(text) : {};
+        }
+        catch {
+            throw new Error(`${method} ${path}: expected JSON response`);
+        }
+        return { data: data, headers: response.headers };
+    }
+    async get(path) {
+        return (await this.request("GET", path)).data;
+    }
+    async maybe(path) {
+        try {
+            return await this.get(path);
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 404)
+                return null;
+            throw e;
+        }
+    }
+    async list(path) {
+        const pathname = path.split("?")[0];
+        const paginated = /^\/(entities|activities|macros|remotes|intg\/drivers|intg\/instances|resources\/[^/]+|intg\/instances\/[^/]+\/entities)$/.test(pathname);
+        if (!paginated) {
+            const data = await this.get(path);
+            if (!Array.isArray(data) || !data.every(isObject))
+                throw new Error(`${path}: expected list response`);
+            return data;
+        }
+        const out = [];
+        let last = "";
+        for (let page = 1; page <= 10000; page++) {
+            const separator = path.includes("?") ? "&" : "?";
+            const { data, headers } = await this.request("GET", `${path}${separator}page=${page}&limit=100`);
+            if (!Array.isArray(data))
+                throw new Error(`${path}: expected list response`);
+            if (!data.every(isObject))
+                throw new Error(`${path}: unexpected list item`);
+            const fingerprint = JSON.stringify(data);
+            if (data.length && fingerprint === last)
+                throw new Error(`${path}: server ignored pagination`);
+            last = fingerprint;
+            out.push(...data);
+            const count = headers.get("pagination-count");
+            if (count !== null && out.length >= Number(count))
+                return out;
+            if (!data.length ||
+                (count === null &&
+                    data.length < Number(headers.get("pagination-limit") ?? 100)))
+                return out;
+        }
+        throw new Error(`${path}: pagination limit exceeded`);
+    }
+    async download(path) {
+        if (!path.startsWith("/") || path.startsWith("//") || path.includes(".."))
+            throw new Error("Invalid API path");
+        const response = await this.transport(new URL(path.slice(1), this.base), {
+            headers: this.token ? { Authorization: `Bearer ${this.token}` } : {},
+            signal: AbortSignal.timeout(180000),
+            redirect: "error",
+        });
+        if (!response.ok)
+            throw new ApiError(response.status, "GET", path);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async version() {
+        return this.get("/pub/version");
+    }
+    async verifyTarget(target) {
+        const v = await this.version();
+        if (v.address !== target.identity || v.model !== "UCR3")
+            throw new Error("Remote identity/model differs from target");
+        if (v.core !== target.version.core || v.api !== target.version.api)
+            throw new Error("Remote firmware changed; reconnect and replan");
+    }
+}
+export async function resolveSecrets(v) {
+    if (Array.isArray(v))
+        return (await Promise.all(v.map(resolveSecrets)));
+    if (isObject(v)) {
+        if (typeof v.$secret === "string") {
+            const source = v.$secret;
+            if (source.startsWith("env:")) {
+                const value = process.env[source.slice(4)];
+                if (!value)
+                    throw new Error(`Missing secret environment variable ${source.slice(4)}`);
+                return value;
+            }
+            if (source.startsWith("keychain:") && process.platform === "darwin") {
+                const name = source.slice(9);
+                const slash = name.indexOf("/");
+                try {
+                    const { stdout } = await promisify(execFile)("security", [
+                        "find-generic-password",
+                        "-s",
+                        slash < 0 ? "uc-config" : name.slice(0, slash),
+                        "-a",
+                        slash < 0 ? name : name.slice(slash + 1),
+                        "-w",
+                    ]);
+                    return stdout.trimEnd();
+                }
+                catch {
+                    throw new Error(`Cannot read Keychain secret ${name}`);
+                }
+            }
+            throw new Error("Secret source must be env:NAME or keychain:service/account");
+        }
+        return Object.fromEntries(await Promise.all(Object.entries(v).map(async ([k, x]) => [k, await resolveSecrets(x)])));
+    }
+    return v;
+}

package/dist/compiler.d.ts

@@ -0,0 +1,5 @@
+import type { Config, Resource } from "./model.js";
+export declare function order(config: Config): string[];
+export declare function validateConfig(config: Config): void;
+export declare function compile(file: string): Promise<Config>;
+export declare function verifyArtifact(resource: Resource): Promise<Buffer>;

package/dist/compiler.js

@@ -0,0 +1,155 @@
+import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { tsImport } from "tsx/esm/api";
+import { assertJson, isObject, references, secretFields } from "./util.js";
+const kinds = new Set([
+    "activity",
+    "macro",
+    "remote",
+    "profile",
+    "profilePage",
+    "profileGroup",
+    "activityGroup",
+    "activityPage",
+    "remotePage",
+    "activityButton",
+    "remoteButton",
+    "settings",
+    "driver",
+    "integration",
+    "entity",
+    "dock",
+    "irCode",
+    "pairing",
+    "asset",
+    "driverArchive",
+]);
+export function order(config) {
+    const result = [];
+    const visiting = new Set();
+    const done = new Set();
+    function visit(key) {
+        if (done.has(key))
+            return;
+        if (visiting.has(key))
+            throw new Error(`Dependency cycle at ${key}`);
+        const r = config.resources[key];
+        if (!r)
+            throw new Error(`Unknown resource reference ${key}`);
+        visiting.add(key);
+        for (const dep of [...references(r), ...(r.dependsOn ?? [])])
+            visit(dep);
+        visiting.delete(key);
+        done.add(key);
+        result.push(key);
+    }
+    for (const key of Object.keys(config.resources).sort())
+        visit(key);
+    return result;
+}
+export function validateConfig(config) {
+    assertJson(config);
+    if (config.schemaVersion !== 1 || !isObject(config.resources))
+        throw new Error("Expected schemaVersion: 1 and resources map");
+    for (const [key, r] of Object.entries(config.resources)) {
+        if (!/^[A-Za-z][A-Za-z0-9_.-]*$/.test(key))
+            throw new Error(`Invalid resource key ${key}`);
+        if (!kinds.has(r.kind) || !isObject(r.data))
+            throw new Error(`${key}: unknown kind or missing data`);
+        const secrets = secretFields(r);
+        if (secrets.length)
+            throw new Error(`${key}: use secret() references for ${secrets.join(", ")}`);
+        if (r.id && r.id.includes(".."))
+            throw new Error(`${key}: invalid identifier`);
+        if ([
+            "profilePage",
+            "profileGroup",
+            "activityPage",
+            "remotePage",
+            "activityButton",
+            "remoteButton",
+            "entity",
+            "irCode",
+            "pairing",
+        ].includes(r.kind) &&
+            !r.parent)
+            throw new Error(`${key}: parent reference or ID required`);
+        if (r.kind.endsWith("Button") &&
+            !/^[A-Z0-9_]+\/(short_press|long_press)$/.test(r.id ?? ""))
+            throw new Error(`${key}: button id must be BUTTON/short_press or BUTTON/long_press`);
+        if (r.kind.endsWith("Page"))
+            validatePage(key, r.data);
+        if (r.kind === "settings" &&
+            (!r.id ||
+                ![
+                    "device",
+                    "display",
+                    "button",
+                    "haptic",
+                    "localization",
+                    "power_saving",
+                    "sound",
+                    "bt",
+                    "profile",
+                    "voice_control",
+                ].includes(r.id)))
+            throw new Error(`${key}: unsupported settings section`);
+        if (r.kind === "integration" && !r.create && !r.id)
+            throw new Error(`${key}: integration needs setup data or existing id`);
+        if ((r.kind === "asset" || r.kind === "driverArchive") && !r.file)
+            throw new Error(`${key}: file required`);
+    }
+    order(config);
+}
+function validatePage(key, data) {
+    if (!Array.isArray(data.items) || !isObject(data.grid))
+        return;
+    const grid = data.grid;
+    const occupied = new Set();
+    for (const item of data.items) {
+        if (!isObject(item) || !isObject(item.location))
+            continue;
+        const x = Number(item.location.x), y = Number(item.location.y);
+        const size = isObject(item.size) ? item.size : {};
+        const w = Number(size.width ?? 1), h = Number(size.height ?? 1);
+        if (![x, y, w, h, grid.width, grid.height].every((n) => typeof n === "number" && Number.isSafeInteger(n)) ||
+            x < 0 ||
+            y < 0 ||
+            w < 1 ||
+            h < 1 ||
+            x + w > Number(grid.width) ||
+            y + h > Number(grid.height))
+            throw new Error(`${key}: widget outside grid`);
+        if (w * h > 10000)
+            throw new Error(`${key}: excessive grid size`);
+        for (let i = x; i < x + w; i++)
+            for (let j = y; j < y + h; j++) {
+                const cell = `${i},${j}`;
+                if (occupied.has(cell))
+                    throw new Error(`${key}: overlapping widgets`);
+                occupied.add(cell);
+            }
+    }
+}
+export async function compile(file) {
+    const mod = await tsImport(resolve(file), import.meta.url);
+    const config = (mod.default?.schemaVersion ? mod.default : mod.default?.default);
+    validateConfig(config);
+    for (const r of Object.values(config.resources))
+        if (r.file) {
+            r.file = resolve(file, "..", r.file);
+            r.sha256 = createHash("sha256")
+                .update(await readFile(r.file))
+                .digest("hex");
+        }
+    return structuredClone(config);
+}
+export async function verifyArtifact(resource) {
+    if (!resource.file || !resource.sha256)
+        throw new Error("Uncompiled file artifact");
+    const bytes = await readFile(resource.file);
+    if (createHash("sha256").update(bytes).digest("hex") !== resource.sha256)
+        throw new Error("File changed since compilation; recompile and replan");
+    return bytes;
+}

package/dist/diagnose.d.ts

@@ -0,0 +1,41 @@
+import type { CoreClient } from "./client.js";
+export interface Orphan {
+    /** Entity ID that is referenced but no longer configured on the remote. */
+    entityId: string;
+    /** Activities/macros (by ID and display name) that still reference it. */
+    usedBy: {
+        id: string;
+        name: string;
+        kind: "activity" | "macro";
+    }[];
+    integrationId?: string;
+    integrationState?: string;
+    /** Integration-local ID (entity ID minus the `<integration>.` prefix). */
+    localId?: string;
+    /** The integration still offers this exact entity: it only needs re-adding. */
+    readdable: boolean;
+    /** Not-yet-configured entities of the same integration and type: likely re-keys. */
+    candidates: {
+        localId: string;
+        entityId: string;
+        name: string;
+    }[];
+    fix: string;
+}
+export interface Diagnosis {
+    orphans: Orphan[];
+    integrations: {
+        id: string;
+        state: string;
+    }[];
+    problems: string[];
+}
+/** Collect every entity ID referenced anywhere in a resource's options. */
+export declare function referencedEntities(value: unknown, out?: Set<string>): Set<string>;
+/**
+ * Read-only health check: finds entity references in activities and macros
+ * that no longer resolve (typically after an integration update or re-key),
+ * then works out the most likely repair for each.
+ */
+export declare function diagnose(client: CoreClient): Promise<Diagnosis>;
+export declare function formatDiagnosis(d: Diagnosis): string;

package/dist/diagnose.js

@@ -0,0 +1,133 @@
+import { isObject } from "./util.js";
+const label = (v) => isObject(v)
+    ? String(v.en ?? v.en_US ?? Object.values(v)[0] ?? "")
+    : String(v ?? "");
+/** Collect every entity ID referenced anywhere in a resource's options. */
+export function referencedEntities(value, out = new Set()) {
+    if (Array.isArray(value))
+        for (const x of value)
+            referencedEntities(x, out);
+    else if (isObject(value))
+        for (const [k, v] of Object.entries(value)) {
+            if (k === "entity_id" && typeof v === "string") {
+                out.add(v);
+            }
+            else if (k === "entity_ids" && Array.isArray(v)) {
+                for (const x of v)
+                    if (typeof x === "string")
+                        out.add(x);
+            }
+            else {
+                referencedEntities(v, out);
+            }
+        }
+    return out;
+}
+/**
+ * Read-only health check: finds entity references in activities and macros
+ * that no longer resolve (typically after an integration update or re-key),
+ * then works out the most likely repair for each.
+ */
+export async function diagnose(client) {
+    const entities = await client.list("/entities");
+    const instances = await client.list("/intg/instances");
+    const known = new Set(entities.map((e) => String(e.entity_id)));
+    const owners = new Map();
+    for (const [kind, path] of [
+        ["activity", "/activities"],
+        ["macro", "/macros"],
+    ]) {
+        for (const summary of await client.list(path)) {
+            const id = String(summary.entity_id);
+            known.add(id);
+            const detail = await client.get(`${path}/${encodeURIComponent(id)}`);
+            for (const ref of referencedEntities(detail.options)) {
+                const list = owners.get(ref) ?? [];
+                list.push({ id, name: label(detail.name), kind });
+                owners.set(ref, list);
+            }
+        }
+    }
+    const available = new Map();
+    const availableFor = async (intg) => {
+        if (!available.has(intg))
+            available.set(intg, await client
+                .list(`/intg/instances/${encodeURIComponent(intg)}/entities?filter=ALL`)
+                .catch(() => []));
+        return available.get(intg);
+    };
+    const orphans = [];
+    for (const [entityId, usedBy] of [...owners].sort()) {
+        if (known.has(entityId))
+            continue;
+        const instance = instances
+            .filter((i) => entityId.startsWith(`${i.integration_id}.`))
+            .sort((a, b) => String(b.integration_id).length - String(a.integration_id).length)[0];
+        const orphan = {
+            entityId,
+            usedBy,
+            readdable: false,
+            candidates: [],
+            fix: "",
+        };
+        orphans.push(orphan);
+        if (!instance) {
+            orphan.fix =
+                "No installed integration owns this ID. Reinstall/set up the integration (see Integration Manager), or remove the reference from remote.config.ts.";
+            continue;
+        }
+        const intg = String(instance.integration_id);
+        orphan.integrationId = intg;
+        orphan.integrationState = String(instance.device_state ?? "UNKNOWN");
+        orphan.localId = entityId.slice(intg.length + 1);
+        const offered = await availableFor(intg);
+        orphan.readdable = offered.some((e) => e.entity_id === orphan.localId);
+        if (orphan.readdable) {
+            orphan.fix = `Re-add the entity: npm run uc -- api POST '/intg/instances/${intg}/entities/${orphan.localId}' --data '{}' --write`;
+            continue;
+        }
+        const type = orphan.localId.split(".")[0];
+        orphan.candidates = offered
+            .filter((e) => !known.has(`${intg}.${e.entity_id}`) &&
+            (!type ||
+                String(e.entity_id).startsWith(`${type}.`) ||
+                e.entity_type === type))
+            .map((e) => ({
+            localId: String(e.entity_id),
+            entityId: `${intg}.${e.entity_id}`,
+            name: label(e.name),
+        }));
+        orphan.fix =
+            orphan.integrationState !== "CONNECTED"
+                ? `Integration ${intg} is ${orphan.integrationState}; reconnect it first, then rerun diagnose.`
+                : orphan.candidates.length
+                    ? "Entity was likely re-keyed by a driver update. Re-add the matching candidate, then replace the old ID everywhere in remote.config.ts and plan."
+                    : "The integration no longer offers this entity. Re-run the integration's setup (web configurator or Integration Manager), or remove the reference.";
+    }
+    const integrations = instances.map((i) => ({
+        id: String(i.integration_id),
+        state: String(i.device_state ?? "UNKNOWN"),
+    }));
+    const problems = integrations
+        .filter((i) => i.state !== "CONNECTED")
+        .map((i) => `Integration ${i.id} is ${i.state}`);
+    return { orphans, integrations, problems };
+}
+export function formatDiagnosis(d) {
+    const lines = [];
+    for (const o of d.orphans) {
+        lines.push(`ORPHAN ${o.entityId}`);
+        lines.push(`  used by: ${o.usedBy.map((u) => `${u.kind} "${u.name}" (${u.id})`).join(", ")}`);
+        if (o.integrationId)
+            lines.push(`  integration: ${o.integrationId} [${o.integrationState}]`);
+        for (const c of o.candidates)
+            lines.push(`  candidate: ${c.entityId} "${c.name}"`);
+        lines.push(`  fix: ${o.fix}`);
+    }
+    for (const p of d.problems)
+        lines.push(`WARN ${p}`);
+    lines.push(d.orphans.length || d.problems.length
+        ? `${d.orphans.length} orphaned entity reference(s), ${d.problems.length} integration problem(s).`
+        : `All clear: ${d.integrations.length} integrations connected, no orphaned entity references.`);
+    return lines.join("\n");
+}

package/dist/dsl.d.ts

@@ -0,0 +1,67 @@
+import type { Config, Id, ObjectValue, Ref, Resource, Secret } from "./model.js";
+import type { components } from "./wire.js";
+export type Schemas = components["schemas"];
+export declare const ref: (key: string) => Ref;
+export declare const secret: (source: `env:${string}` | `keychain:${string}`, version?: string) => Secret;
+export declare const defineRemote: (config: Config) => Config;
+export declare const resource: (kind: Resource["kind"], options: Omit<Resource, "kind">) => Resource;
+export declare const command: (entity: Id, cmdId: string, params?: ObjectValue) => ObjectValue;
+export declare const localCommand: (cmdId: string, params?: ObjectValue) => ObjectValue;
+export declare const delay: (ms: number) => ObjectValue;
+export interface ActivityOptions {
+    id?: string;
+    name: string;
+    icon?: string;
+    entities: Id[];
+    on?: ObjectValue[];
+    off?: ObjectValue[];
+    options?: ObjectValue;
+}
+export declare function activity(o: ActivityOptions): Resource;
+export declare const integration: (o: {
+    id?: string;
+    driver: Id;
+    name: string;
+    setup?: ObjectValue;
+    deviceId?: string;
+}) => Resource;
+export declare const entity: (o: {
+    id?: string;
+    integration: Id;
+    entityId: string;
+    data?: ObjectValue;
+}) => Resource;
+export declare const driver: (id: string, data: ObjectValue) => Resource;
+export declare const dock: (o: {
+    id?: string;
+    setup: ObjectValue;
+    data?: ObjectValue;
+}) => Resource;
+export declare const remote: (o: {
+    id?: string;
+    create: Schemas["RemoteCreate"];
+    data?: Schemas["RemoteUpdate"];
+}) => Resource;
+export declare const profile: (data: Schemas["ProfileRequest"]) => Resource;
+export declare const settings: (section: string, data: ObjectValue) => Resource;
+export declare const macro: (o: {
+    id?: string;
+    name: string;
+    entities: Id[];
+    steps: ObjectValue[];
+}) => Resource;
+export declare const bind: (parent: Id, button: string, cmd: ObjectValue, press?: "short_press" | "long_press", scope?: "activity" | "remote") => Resource;
+export declare const page: (parent: Id, data: ObjectValue, id?: string, scope?: "activity" | "remote") => Resource;
+export declare const button: (o: {
+    label: string;
+    at: [number, number];
+    size?: [number, number];
+    command: ObjectValue;
+}) => ObjectValue;
+export declare const pairing: (parent: Id, expectedPeer?: string) => Resource;
+export declare const irCode: (parent: Id, id: string, code: {
+    format: string;
+    value: string;
+}) => Resource;
+export declare const asset: (type: string, file: string) => Resource;
+export declare const driverArchive: (id: string, file: string) => Resource;

package/dist/dsl.js

@@ -0,0 +1,103 @@
+export const ref = (key) => ({ $ref: key });
+export const secret = (source, version) => ({ $secret: source, ...(version ? { version } : {}) });
+export const defineRemote = (config) => config;
+export const resource = (kind, options) => ({ kind, ...options });
+export const command = (entity, cmdId, params) => ({
+    entity_id: entity,
+    cmd_id: cmdId,
+    ...(params ? { params } : {}),
+});
+export const localCommand = (cmdId, params) => ({ cmd_id: cmdId, ...(params ? { params } : {}) });
+export const delay = (ms) => ({
+    type: "delay",
+    delay: ms,
+});
+const sequence = (steps) => steps.map((s) => (s.type === "delay" ? s : { type: "command", command: s }));
+export function activity(o) {
+    const sequences = {
+        ...(o.on ? { on: sequence(o.on) } : {}),
+        ...(o.off ? { off: sequence(o.off) } : {}),
+    };
+    const base = { name: { en: o.name }, ...(o.icon ? { icon: o.icon } : {}) };
+    return resource("activity", {
+        ...(o.id ? { id: o.id } : {}),
+        create: { ...base, options: { entity_ids: o.entities } },
+        data: {
+            ...base,
+            options: {
+                ...o.options,
+                entity_ids: o.entities,
+                ...(Object.keys(sequences).length ? { sequences } : {}),
+            },
+        },
+    });
+}
+export const integration = (o) => resource("integration", {
+    ...(o.id ? { id: o.id } : {}),
+    data: {
+        driver_id: o.driver,
+        name: { en: o.name },
+        ...(o.deviceId ? { device_id: o.deviceId } : {}),
+    },
+    create: {
+        driver_id: o.driver,
+        name: { en: o.name },
+        setup_data: o.setup ?? {},
+    },
+});
+export const entity = (o) => resource("entity", {
+    ...(o.id ? { id: o.id } : {}),
+    parent: o.integration,
+    create: { entity_id: o.entityId },
+    data: o.data ?? {},
+});
+export const driver = (id, data) => resource("driver", { id, create: { driver_id: id, ...data }, data });
+export const dock = (o) => resource("dock", {
+    ...(o.id ? { id: o.id } : {}),
+    create: o.setup,
+    data: o.data ?? {},
+});
+export const remote = (o) => resource("remote", {
+    ...(o.id ? { id: o.id } : {}),
+    create: o.create,
+    data: (o.data ?? { name: o.create.name }),
+});
+export const profile = (data) => resource("profile", {
+    ...(data.profile_id ? { id: data.profile_id } : {}),
+    data: data,
+});
+export const settings = (section, data) => resource("settings", { id: section, data });
+export const macro = (o) => resource("macro", {
+    ...(o.id ? { id: o.id } : {}),
+    create: { name: { en: o.name }, options: { entity_ids: o.entities } },
+    data: {
+        name: { en: o.name },
+        options: { entity_ids: o.entities, sequence: sequence(o.steps) },
+    },
+});
+export const bind = (parent, button, cmd, press = "short_press", scope = "activity") => resource(scope === "activity" ? "activityButton" : "remoteButton", {
+    parent,
+    id: `${button}/${press}`,
+    data: { [press]: cmd },
+});
+export const page = (parent, data, id, scope = "activity") => resource(scope === "activity" ? "activityPage" : "remotePage", {
+    parent,
+    ...(id ? { id } : {}),
+    data,
+});
+export const button = (o) => ({
+    type: "text",
+    text: o.label,
+    location: { x: o.at[0], y: o.at[1] },
+    ...(o.size ? { size: { width: o.size[0], height: o.size[1] } } : {}),
+    command: o.command,
+});
+export const pairing = (parent, expectedPeer) => resource("pairing", {
+    parent,
+    data: expectedPeer
+        ? { paired: true, peer: { address: expectedPeer } }
+        : { paired: true },
+});
+export const irCode = (parent, id, code) => resource("irCode", { parent, id, data: code });
+export const asset = (type, file) => resource("asset", { resourceType: type, file, data: {} });
+export const driverArchive = (id, file) => resource("driverArchive", { id, file, data: {} });