uc-config 0.1.0

package/dist/inventory.js

@@ -0,0 +1,236 @@
+import { route, importShape } from "./adapter.js";
+import { ApiError } from "./client.js";
+import { isObject, secretFields } from "./util.js";
+import { writable } from "./schema.js";
+export async function inventory(client) {
+    const result = {
+        version: await client.version(),
+        collections: {},
+        settings: {},
+        unsupported: [],
+    };
+    for (const [name, path, field] of [
+        ["entities", "/entities", "entity_id"],
+        ["activities", "/activities", "entity_id"],
+        ["macros", "/macros", "entity_id"],
+        ["profiles", "/profiles", "profile_id"],
+        ["activityGroups", "/activity_groups", "group_id"],
+        ["drivers", "/intg/drivers", "driver_id"],
+        ["integrations", "/intg/instances", "integration_id"],
+        ["docks", "/docks", "dock_id"],
+        ["irRemotes", "/remotes?kind=IR", "entity_id"],
+        ["btRemotes", "/remotes?kind=BT", "entity_id"],
+        ["externalRemotes", "/remotes?kind=EXTERNAL", "entity_id"],
+    ]) {
+        try {
+            const list = await client.list(path);
+            const base = name === "docks" ? "/docks/devices" : path.split("?")[0];
+            result.collections[name] = await Promise.all(list.map((x) => client.get(`${base}/${encodeURIComponent(String(x[field]))}`)));
+        }
+        catch (e) {
+            if (e instanceof ApiError && [404, 405].includes(e.status))
+                result.unsupported.push(path);
+            else
+                throw e;
+        }
+    }
+    for (const section of [
+        "device",
+        "display",
+        "button",
+        "haptic",
+        "localization",
+        "power_saving",
+        "sound",
+        "bt",
+        "profile",
+        "voice_control",
+    ]) {
+        try {
+            result.settings[section] = await client.get(`/cfg/${section}`);
+        }
+        catch (e) {
+            if (e instanceof ApiError && [404, 405].includes(e.status))
+                result.unsupported.push(`/cfg/${section}`);
+            else
+                throw e;
+        }
+    }
+    return result;
+}
+export async function importConfig(client) {
+    const inv = await inventory(client);
+    const resources = {};
+    const warnings = [...inv.unsupported.map((p) => `Unsupported endpoint ${p}`)];
+    let serial = 0;
+    const add = (r) => {
+        const key = `${r.kind}${++serial}`;
+        resources[key] = r;
+        return key;
+    };
+    for (const [collection, kind, field] of [
+        ["activities", "activity", "entity_id"],
+        ["macros", "macro", "entity_id"],
+        ["profiles", "profile", "profile_id"],
+        ["activityGroups", "activityGroup", "group_id"],
+        ["integrations", "integration", "integration_id"],
+        ["docks", "dock", "dock_id"],
+        ["irRemotes", "remote", "entity_id"],
+        ["btRemotes", "remote", "entity_id"],
+        ["externalRemotes", "remote", "entity_id"],
+    ]) {
+        for (const item of inv.collections[collection] ?? []) {
+            const id = String(item[field]);
+            const r = { kind, id, data: {} };
+            const rt = route(r, id);
+            r.data = writable(rt.itemTemplate, "patch", importShape(r, item));
+            if (kind === "integration")
+                r.data = { name: item.name, driver_id: item.driver_id };
+            if (kind === "dock")
+                r.data = Object.fromEntries(Object.entries(r.data).filter(([k]) => !["token", "wifi"].includes(k)));
+            const secrets = secretFields(r.data);
+            if (secrets.length) {
+                warnings.push(`${id}: secret-bearing settings require manual secret() references`);
+                continue;
+            }
+            const key = add(r);
+            if (kind === "integration" || kind === "dock")
+                warnings.push(`${key}: existing resource imported; supply create/setup inputs and secret references to reproduce on a new target`);
+            if (kind === "remote" && collection !== "externalRemotes")
+                warnings.push(`${key}: add creation parameters from inventory for fresh-target provisioning; Bluetooth pairings require pairing steps`);
+            if (kind === "activity" || kind === "remote") {
+                const prefix = kind === "activity" ? "activities" : "remotes";
+                try {
+                    const buttons = await client.get(`/${prefix}/${encodeURIComponent(id)}/buttons`);
+                    if (!Array.isArray(buttons))
+                        throw new Error("Unexpected button list");
+                    for (const b of buttons.filter(isObject))
+                        for (const press of ["short_press", "long_press"])
+                            if (isObject(b[press]))
+                                add({
+                                    kind: kind === "activity" ? "activityButton" : "remoteButton",
+                                    parent: { $ref: key },
+                                    id: `${b.button}/${press}`,
+                                    data: { [press]: b[press] },
+                                });
+                    const pages = await client.list(`/${prefix}/${encodeURIComponent(id)}/ui/pages`);
+                    for (const p of pages)
+                        add({
+                            kind: kind === "activity" ? "activityPage" : "remotePage",
+                            parent: { $ref: key },
+                            id: String(p.page_id),
+                            data: writable(`/${prefix}/{entityId}/ui/pages/{pageId}`, "patch", p),
+                        });
+                }
+                catch (e) {
+                    if (e instanceof ApiError && [404, 405].includes(e.status))
+                        warnings.push(`${key}: button/page endpoints unavailable; customization not imported`);
+                    else
+                        throw e;
+                }
+            }
+            if (kind === "profile")
+                for (const child of ["pages", "groups"]) {
+                    const list = await client.list(`/profiles/${encodeURIComponent(id)}/${child}`);
+                    for (const c of list) {
+                        const group = child === "groups";
+                        add({
+                            kind: group ? "profileGroup" : "profilePage",
+                            parent: { $ref: key },
+                            id: String(c[group ? "group_id" : "page_id"]),
+                            data: writable(`/profiles/{profileId}/${child}/{${group ? "groupId" : "pageId"}}`, "patch", c),
+                        });
+                    }
+                }
+            if (collection === "irRemotes") {
+                const ir = await client.get(`/remotes/${encodeURIComponent(id)}/ir`);
+                if (Array.isArray(ir.codes))
+                    for (const code of ir.codes.filter(isObject))
+                        if (typeof code.cmd_id === "string" &&
+                            isObject(code.code) &&
+                            code.code.value &&
+                            code.code.format)
+                            add({
+                                kind: "irCode",
+                                parent: { $ref: key },
+                                id: code.cmd_id,
+                                data: {
+                                    format: code.code.format,
+                                    value: code.code.value,
+                                },
+                            });
+            }
+        }
+    }
+    for (const item of inv.collections.entities ?? []) {
+        if (["activity", "macro", "remote"].includes(String(item.entity_type)) ||
+            typeof item.integration_id !== "string" ||
+            !item.integration_id)
+            continue;
+        add({
+            kind: "entity",
+            id: String(item.entity_id),
+            parent: item.integration_id,
+            data: writable("/entities/{entityId}", "patch", item),
+        });
+    }
+    const usedDrivers = new Set((inv.collections.integrations ?? []).map((i) => i.driver_id));
+    for (const item of inv.collections.drivers ?? []) {
+        if (!usedDrivers.has(item.driver_id))
+            continue;
+        const data = writable("/intg/drivers/{driverId}", "patch", item);
+        // Credentials returned by the API must never be exported into source.
+        delete data.token;
+        if (secretFields(data).length) {
+            warnings.push(`${item.driver_id}: driver settings contain secrets; provide secret references manually`);
+            continue;
+        }
+        add({ kind: "driver", id: String(item.driver_id), data });
+    }
+    for (const [section, data] of Object.entries(inv.settings)) {
+        const picked = writable(`/cfg/${section}`, "patch", data);
+        if (section === "voice_control" &&
+            isObject(picked.voice_assistant) &&
+            Object.keys(picked.voice_assistant).length === 0) {
+            delete picked.voice_assistant;
+            warnings.push("voice_control: disabled assistant has no writable entity_id; its empty read-only representation is preserved but not owned.");
+        }
+        if (!Object.keys(picked).length)
+            continue;
+        if (!secretFields(picked).length)
+            add({ kind: "settings", id: section, data: picked });
+        else
+            warnings.push(`${section}: secret-bearing settings omitted; configure secret references`);
+    }
+    warnings.push("Imported arrays (page items, sequences, membership) are owned as whole fields. Review before adoption.");
+    warnings.push("Driver installation archives, external-service deployment and binary assets cannot be reconstructed from this import; declare their local artifacts separately.");
+    return { config: { schemaVersion: 1, resources }, warnings };
+}
+export function generateBindings(inv) {
+    const entities = inv.collections.entities ?? [];
+    const ids = entities.map((e) => String(e.entity_id));
+    const entries = entities.map((e, i) => {
+        const detail = [...(inv.collections.activities ?? [])]
+            .flatMap((a) => isObject(a.options) && Array.isArray(a.options.included_entities)
+            ? a.options.included_entities.filter(isObject)
+            : Array.isArray(a.entities)
+                ? a.entities.filter(isObject)
+                : [])
+            .find((x) => x.entity_id === e.entity_id);
+        const commands = [
+            ...(Array.isArray(detail?.entity_commands) ? detail.entity_commands : []),
+            ...(Array.isArray(detail?.simple_commands) ? detail.simple_commands : []),
+            ...(isObject(e.options) && Array.isArray(e.options.simple_commands)
+                ? e.options.simple_commands
+                : []),
+        ]
+            .map((c) => typeof c === "string"
+            ? c
+            : isObject(c)
+                ? String(c.cmd_id ?? c.id ?? "")
+                : "")
+            .filter(Boolean);
+        return `  entity${i + 1}: { id: ${JSON.stringify(e.entity_id)}, name: ${JSON.stringify(e.name)}, commands: ${JSON.stringify([...new Set(commands)])} },`;
+    });
+    return `// Generated from remote inventory. Exact command IDs; rename aliases as needed.\nexport const devices = {\n${entries.join("\n")}\n} as const;\nexport type EntityId = ${ids.length ? ids.map((id) => JSON.stringify(id)).join(" | ") : "never"};\n`;
+}

package/dist/model.d.ts

@@ -0,0 +1,91 @@
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export type ObjectValue = {
+    [key: string]: Json;
+};
+export type Ref = {
+    $ref: string;
+};
+export type Secret = {
+    $secret: string;
+    version?: string;
+};
+export type Id = string | Ref;
+export type Kind = "activity" | "macro" | "remote" | "profile" | "profilePage" | "profileGroup" | "activityGroup" | "activityPage" | "remotePage" | "activityButton" | "remoteButton" | "settings" | "driver" | "integration" | "entity" | "dock" | "irCode" | "pairing" | "asset" | "driverArchive";
+export interface Resource {
+    kind: Kind;
+    id?: string;
+    parent?: Id;
+    data: ObjectValue;
+    create?: ObjectValue;
+    dependsOn?: string[];
+    file?: string;
+    sha256?: string;
+    resourceType?: string;
+}
+export interface Config {
+    schemaVersion: 1;
+    resources: Record<string, Resource>;
+}
+export interface Version {
+    model: string;
+    address: string;
+    api: string;
+    core: string;
+    [key: string]: unknown;
+}
+export interface Target {
+    host: string;
+    identity: string;
+    version: Version;
+    tokenEnv: string;
+}
+export interface Binding {
+    id: string;
+    resource: Resource;
+    baseline: ObjectValue;
+    setupHash?: string;
+}
+export interface SetupCheckpoint {
+    key: string;
+    kind: "integration" | "dock";
+    id: string;
+    resource: Resource;
+    beforeIds: string[];
+    existingId?: string;
+    status: string;
+}
+export interface State {
+    version: 1;
+    revision: number;
+    identity: string;
+    bindings: Record<string, Binding>;
+    setups: Record<string, SetupCheckpoint>;
+}
+export interface Observation {
+    id?: string;
+    value: ObjectValue | null;
+    resource: Resource;
+}
+export interface Operation {
+    key: string;
+    action: "create" | "update" | "adopt" | "forget" | "delete" | "reconfigure";
+    resource: Resource;
+    id?: string;
+    before: ObjectValue | null;
+    desired: ObjectValue;
+}
+export interface Plan {
+    version: 1;
+    adapter: string;
+    target: Target;
+    stateRevision: number;
+    configHash: string;
+    operations: Operation[];
+    deferred: string[];
+    conflicts: string[];
+    createdAt: string;
+    digest: string;
+}
+export declare const emptyState: (identity: string) => State;

package/dist/model.js

@@ -0,0 +1,7 @@
+export const emptyState = (identity) => ({
+    version: 1,
+    revision: 0,
+    identity,
+    bindings: {},
+    setups: {},
+});

package/dist/planner.d.ts

@@ -0,0 +1,12 @@
+import type { Config, ObjectValue, Plan, State, Target } from "./model.js";
+import { Adapter } from "./adapter.js";
+export interface PlanOptions {
+    overwriteDrift?: boolean;
+    adoptDrift?: boolean;
+    prune?: boolean;
+}
+export declare function configurationView(live: ObjectValue, shape: ObjectValue, baseline?: ObjectValue): ObjectValue;
+export declare function makePlan(config: Config, target: Target, state: State, adapter: Adapter, options?: PlanOptions): Promise<Plan>;
+export declare const planDigest: (plan: Plan) => string;
+export declare function checkPlan(plan: Plan): void;
+export declare function formatPlan(plan: Plan): string;

package/dist/planner.js

@@ -0,0 +1,248 @@
+import { ADAPTER, desired } from "./adapter.js";
+import { order, validateConfig } from "./compiler.js";
+import { equal, get, hash, isObject, leaves, merge, project, references, resolveRefs, redact, } from "./util.js";
+export function configurationView(live, shape, baseline) {
+    const view = project(live, shape);
+    function secrets(target, wanted, prior) {
+        for (const [k, v] of Object.entries(wanted))
+            if (isObject(v)) {
+                if ("$secret" in v) {
+                    if (prior?.[k])
+                        target[k] = prior[k];
+                    else
+                        delete target[k];
+                }
+                else {
+                    const child = isObject(target[k]) ? target[k] : {};
+                    secrets(child, v, isObject(prior?.[k]) ? prior[k] : undefined);
+                    if (Object.keys(child).length || isObject(target[k]))
+                        target[k] = child;
+                }
+            }
+    }
+    secrets(view, shape, baseline);
+    return view;
+}
+export async function makePlan(config, target, state, adapter, options = {}) {
+    validateConfig(config);
+    await adapter.client.verifyTarget(target);
+    if (state.identity !== target.identity)
+        throw new Error("State belongs to a different remote");
+    if (options.overwriteDrift && options.adoptDrift)
+        throw new Error("Choose either adopt or overwrite drift");
+    const operations = [];
+    const deferred = [];
+    const conflicts = [];
+    const changed = new Set();
+    // Existing resources can be adopted and referenced in one read-only planning pass.
+    const observedState = structuredClone(state);
+    for (const key of order(config)) {
+        const original = config.resources[key];
+        const deps = [...references(original), ...(original.dependsOn ?? [])];
+        if (deps.some((dep) => !observedState.bindings[dep] || changed.has(dep))) {
+            deferred.push(key);
+            changed.add(key);
+            continue;
+        }
+        try {
+            if (state.setups[key]) {
+                deferred.push(key);
+                changed.add(key);
+                continue;
+            }
+            const obs = await adapter.observe(original, observedState, key);
+            const r = obs.resource;
+            const want = desired(r);
+            const bound = state.bindings[key];
+            if (bound && r.id && bound.id !== r.id)
+                throw new Error("Explicit id differs from saved mapping; use a different logical key or explicit state adoption");
+            if (bound &&
+                (bound.resource.kind !== r.kind ||
+                    !equal(resolveRefs(bound.resource.parent, state), r.parent)))
+                throw new Error("Resource kind/parent changed; explicit migration required");
+            if (bound &&
+                r.kind === "integration" &&
+                r.create &&
+                !equal(bound.resource.create, original.create)) {
+                const old = resolveRefs(bound.resource, state);
+                if (old.create?.driver_id !== r.create.driver_id ||
+                    old.data.device_id !== r.data.device_id)
+                    throw new Error("Integration driver/device identity changed; explicit replacement required");
+                if (!equal(old.create?.setup_data, r.create.setup_data)) {
+                    if (!obs.value)
+                        throw new Error("Integration missing");
+                    operations.push({
+                        key,
+                        action: "reconfigure",
+                        resource: original,
+                        id: obs.id,
+                        before: configurationView(obs.value, merge(bound.baseline, want), bound.baseline),
+                        desired: want,
+                    });
+                    changed.add(key);
+                    continue;
+                }
+            }
+            if (bound &&
+                ["dock", "remote", "entity"].includes(r.kind) &&
+                r.create &&
+                !equal(bound.resource.create, original.create)) {
+                const immutable = (x) => Object.fromEntries(Object.entries(x.create ?? {}).filter(([k]) => !["name", "icon", "description"].includes(k)));
+                if (!equal(immutable(bound.resource), immutable(original)))
+                    throw new Error("Immutable provisioning inputs changed; explicit replacement required");
+            }
+            if (!obs.value && bound)
+                throw new Error("Managed resource disappeared; reconcile its state before recreation");
+            if (!obs.value) {
+                adapter.validate(r, true);
+                if (![
+                    "asset",
+                    "driverArchive",
+                    "entity",
+                    "integration",
+                    "dock",
+                    "activity",
+                    "macro",
+                ].includes(r.kind))
+                    await adapter.validateCommands(r);
+                const initial = ["activity", "macro"].includes(r.kind)
+                    ? (r.create ?? want)
+                    : want;
+                if (!equal(initial, want))
+                    deferred.push(key);
+                operations.push({
+                    key,
+                    action: "create",
+                    resource: original,
+                    ...(obs.id ? { id: obs.id } : {}),
+                    before: null,
+                    desired: initial,
+                });
+                changed.add(key);
+                continue;
+            }
+            adapter.validate(r, false);
+            let effective = want;
+            const before = configurationView(obs.value, merge(bound?.baseline ?? {}, want), bound?.baseline);
+            const conflictsHere = [];
+            if (bound)
+                for (const [path, previous] of leaves(bound.baseline)) {
+                    const intended = get(want, path);
+                    if (intended === undefined)
+                        continue;
+                    const current = get(before, path);
+                    if (!equal(current, previous) && !equal(current, intended))
+                        conflictsHere.push(path.join("."));
+                }
+            if (conflictsHere.length && !options.overwriteDrift) {
+                if (options.adoptDrift) {
+                    // Adoption requires editing source to current values before the next apply.
+                    throw new Error(`Drift at ${conflictsHere.join(", ")}; import current configuration and update source to adopt it`);
+                }
+                throw new Error(`Drift at ${conflictsHere.join(", ")}; import/adopt live changes or explicitly plan --overwrite-drift`);
+            }
+            const changedData = !equal(configurationView(obs.value, effective, bound?.baseline), effective);
+            if (changedData)
+                await adapter.validateCommands({
+                    ...r,
+                    ...(obs.id ? { id: obs.id } : {}),
+                });
+            if (changedData ||
+                !bound ||
+                !equal(bound.baseline, effective) ||
+                !equal(bound.resource, original)) {
+                operations.push({
+                    key,
+                    action: changedData ? "update" : "adopt",
+                    resource: original,
+                    id: obs.id,
+                    before,
+                    desired: effective,
+                });
+                if (changedData)
+                    changed.add(key);
+                else if (obs.id)
+                    observedState.bindings[key] = {
+                        id: obs.id,
+                        resource: original,
+                        baseline: effective,
+                    };
+            }
+        }
+        catch (e) {
+            conflicts.push(`${key}: ${e.message}`);
+            changed.add(key);
+        }
+    }
+    for (const key of Object.keys(state.bindings))
+        if (!config.resources[key]) {
+            if (!options.prune) {
+                conflicts.push(`${key}: managed resource removed from source; plan --prune to delete or state forget to relinquish ownership`);
+                continue;
+            }
+            const binding = state.bindings[key];
+            try {
+                await adapter.assertDeletable(resolveRefs(binding.resource, state), binding.id);
+                const obs = await adapter.observe(binding.resource, state, key);
+                if (!obs.value)
+                    throw new Error("Resource already absent; use state forget");
+                operations.push({
+                    key,
+                    action: "delete",
+                    resource: binding.resource,
+                    id: binding.id,
+                    before: configurationView(obs.value, binding.baseline, binding.baseline),
+                    desired: binding.baseline,
+                });
+            }
+            catch (e) {
+                conflicts.push(`${key}: ${e.message}`);
+            }
+        }
+    const plan = {
+        version: 1,
+        adapter: ADAPTER,
+        target,
+        stateRevision: state.revision,
+        configHash: hash(config),
+        operations,
+        deferred,
+        conflicts,
+        createdAt: new Date().toISOString(),
+        digest: "",
+    };
+    plan.digest = planDigest(plan);
+    return plan;
+}
+export const planDigest = (plan) => hash({ ...plan, digest: "" });
+export function checkPlan(plan) {
+    if (plan.version !== 1 ||
+        plan.adapter !== ADAPTER ||
+        plan.digest !== planDigest(plan))
+        throw new Error("Invalid, modified or incompatible plan; regenerate it");
+    if (plan.conflicts.length)
+        throw new Error(`Plan has conflicts:\n${plan.conflicts.join("\n")}`);
+}
+export function formatPlan(plan) {
+    return [
+        `Target: ${plan.target.host} (${plan.target.version.model}, core ${plan.target.version.core})`,
+        ...plan.operations.flatMap((op) => {
+            const header = `${op.action === "create" ? "+" : op.action === "delete" ? "-" : op.action === "adopt" ? "=" : "~"} ${op.action} ${op.key} (${op.resource.kind}${op.id ? `, ${op.id}` : ""})`;
+            const display = (value) => {
+                const text = value === undefined ? "(absent)" : JSON.stringify(redact(value));
+                return text.length > 180
+                    ? text.slice(0, 180) + "… (full value in saved plan)"
+                    : text;
+            };
+            const changes = leaves(op.desired)
+                .filter(([path, v]) => !equal(get(op.before, path), v))
+                .map(([path, v]) => `    ${path.join(".")}: ${display(get(op.before, path))} -> ${display(v)}`);
+            if (op.action === "reconfigure")
+                changes.push(`    setup inputs: ${display(op.resource.create?.setup_data)}`);
+            return [header, ...changes];
+        }),
+        ...plan.deferred.map((key) => `… deferred ${key}: apply prerequisites/resume setup, then replan`),
+        ...plan.conflicts.map((c) => `! ${c}`),
+        `${plan.operations.length} operations, ${plan.deferred.length} deferred, ${plan.conflicts.length} conflicts`,
+    ].join("\n");
+}

package/dist/recovery.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from "./adapter.js";
+import type { Journal } from "./engine.js";
+import type { Plan, State, Target } from "./model.js";
+export declare function rollbackPlan(journal: Journal, target: Target, state: State, adapter: Adapter): Promise<Plan>;

package/dist/recovery.js

@@ -0,0 +1,63 @@
+import { ADAPTER } from "./adapter.js";
+import { configurationView, planDigest } from "./planner.js";
+import { equal, get, hash, leaves, merge } from "./util.js";
+export async function rollbackPlan(journal, target, state, adapter) {
+    await adapter.client.verifyTarget(target);
+    const operations = [];
+    const conflicts = [];
+    for (const entry of [...journal.entries].reverse()) {
+        const b = state.bindings[entry.key];
+        if (!b) {
+            conflicts.push(`${entry.key}: missing mapping; deletion/uncertain creation requires explicit recovery`);
+            continue;
+        }
+        if (entry.before === null) {
+            conflicts.push(`${entry.key}: created resource has no prior image; remove it through a separate prune plan`);
+            continue;
+        }
+        if (["integration", "dock", "driverArchive", "asset", "pairing"].includes(b.resource.kind)) {
+            conflicts.push(`${entry.key}: provisioning/pairing/upload side effects require explicit recovery`);
+            continue;
+        }
+        const obs = await adapter.observe(b.resource, state, entry.key);
+        if (!obs.value) {
+            conflicts.push(`${entry.key}: no live resource`);
+            continue;
+        }
+        const shape = merge(b.baseline, entry.before);
+        const current = configurationView(obs.value, shape, b.baseline);
+        if (!equal(configurationView(obs.value, b.baseline, b.baseline), b.baseline)) {
+            conflicts.push(`${entry.key}: changed after apply; reconcile drift before rollback`);
+            continue;
+        }
+        const absent = leaves(b.baseline).filter(([path]) => get(entry.before, path) === undefined);
+        if (absent.length) {
+            conflicts.push(`${entry.key}: fields absent before apply require explicit clearing: ${absent.map(([p]) => p.join(".")).join(", ")}`);
+            continue;
+        }
+        const r = { ...b.resource, data: entry.before };
+        adapter.validate(r, false);
+        operations.push({
+            key: entry.key,
+            action: "update",
+            id: b.id,
+            resource: r,
+            before: current,
+            desired: entry.before,
+        });
+    }
+    const plan = {
+        version: 1,
+        adapter: ADAPTER,
+        target,
+        stateRevision: state.revision,
+        configHash: hash(journal),
+        operations,
+        deferred: [],
+        conflicts,
+        createdAt: new Date().toISOString(),
+        digest: "",
+    };
+    plan.digest = planDigest(plan);
+    return plan;
+}

package/dist/schema.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectValue } from "./model.js";
+export declare const spec: any;
+export declare function validateRequest(path: string, method: string, data: unknown): void;
+export declare function writable(path: string, method: string, value: ObjectValue): ObjectValue;