zidane-ui 9.1.4 → 9.1.6

package/dist/session/headless/fixture-host.js

@@ -1,46 +1,23 @@
 import { createArtifactsState, groupArtifactRows } from "./artifacts.js";
 import { createQueueState } from "./queue.js";
 import { createRunningWorkState } from "./running-work.js";
-import { createTodosState } from "./todos.js";
+import { createSchedulesState } from "./schedules.js";
+import { createPlansState } from "./plans.js";
+import { createSecretsState } from "./secrets.js";
+import { createFixtureScheduleBackend } from "./fixture-schedules.js";
+import { createFixturePlansBackend } from "./fixture-plans.js";
+import { isSecretName } from "zidane/chat/pure";
 //#region src/session/headless/fixture-host.ts
 /**
-* Counts todo items by status.
-*
-* @param items - The todo list.
-*/
-function tallyTodos(items) {
-	const tally = {
-		pending: 0,
-		in_progress: 0,
-		completed: 0,
-		cancelled: 0
-	};
-	for (const item of items) tally[item.status]++;
-	return tally;
-}
-/**
-* A todo snapshot of a list, as a backend broadcasts it.
-*
-* @param items - The live list.
-* @param archive - The last non-empty list (shown read-only when the live one is empty).
-*/
-function todosSnapshotOf(items, archive = []) {
-	return {
-		runId: "fixture",
-		todos: [...items],
-		archive: [...archive],
-		inProgress: items.find((t) => t.status === "in_progress") ?? null,
-		tally: tallyTodos(items)
-	};
-}
-/**
 * Creates a {@link FixtureSessionHost} over the fixture's data.
 *
 * @param fixture - The data per session.
 */
 function createFixtureSessionHost(fixture = {}) {
-	const todoLists = new Map(Object.entries(fixture.todos ?? {}).map(([id, items]) => [id, [...items]]));
-	const archives = /* @__PURE__ */ new Map();
+	const planBackend = createFixturePlansBackend({
+		...fixture.plans ? { plans: fixture.plans } : {},
+		...fixture.todos ? { todos: fixture.todos } : {}
+	});
 	const queues = new Map(Object.entries(fixture.queue ?? {}).map(([id, entries]) => [id, [...entries]]));
 	const artifacts = new Map(Object.entries(fixture.artifacts ?? {}).map(([id, rows]) => [id, [...rows]]));
 	const work = new Map(Object.entries(fixture.work ?? {}).map(([id, list]) => [id, [...list]]));
@@ -94,10 +71,23 @@ function createFixtureSessionHost(fixture = {}) {
 	};
 	const sides = fixture.sides ? new Map(Object.entries(fixture.sides)) : null;
 	let sideSeq = 0;
-	const snapshotOf = (sessionId) => {
-		const items = todoLists.get(sessionId);
-		return items ? todosSnapshotOf(items, archives.get(sessionId)) : null;
+	const secretLists = new Map(Object.entries(fixture.secrets ?? {}).map(([id, list]) => [id, [...list]]));
+	const secretsState = createSecretsState(async (sessionId) => secretLists.get(sessionId) ?? []);
+	const writeSecrets = (sessionId, entries) => {
+		secretLists.set(sessionId, [...entries]);
+		secretsState.wakeAll();
 	};
+	const secretsSaveError = fixture.secretsSaveError;
+	const scheduleBackend = createFixtureScheduleBackend({
+		...fixture.schedules ? { schedules: fixture.schedules } : {},
+		...fixture.scheduleFires ? { fires: fixture.scheduleFires } : {},
+		...fixture.schedulesEnabled === false ? { enabled: false } : {}
+	});
+	const schedulesState = createSchedulesState({
+		status: async () => scheduleBackend.status(),
+		list: async () => scheduleBackend.list()
+	});
+	scheduleBackend.subscribe(() => schedulesState.wake());
 	const items = (sessionId) => (queues.get(sessionId) ?? []).map((e) => ({
 		id: e.id,
 		text: e.text,
@@ -106,13 +96,11 @@ function createFixtureSessionHost(fixture = {}) {
 			...a.name ? { name: a.name } : {}
 		})) } : {}
 	}));
-	const todos = createTodosState(async (sessionId) => snapshotOf(sessionId));
-	const writeTodos = (sessionId, next) => {
-		const prev = todoLists.get(sessionId) ?? [];
-		if (next.length === 0 && prev.length > 0) archives.set(sessionId, prev);
-		todoLists.set(sessionId, [...next]);
-		todos.push(sessionId, snapshotOf(sessionId));
-	};
+	const plans = createPlansState(async (sessionId) => planBackend.snapshot(sessionId));
+	planBackend.subscribe((sessionId) => {
+		const snap = planBackend.snapshot(sessionId);
+		if (snap) plans.push(sessionId, snap);
+	});
 	const writeQueue = (sessionId, entries) => {
 		queues.set(sessionId, entries);
 		queue.replace(sessionId, items(sessionId));
@@ -132,12 +120,14 @@ function createFixtureSessionHost(fixture = {}) {
 	});
 	const artifactsState = createArtifactsState(async (sessionId) => groupArtifactRows(artifacts.get(sessionId) ?? [], fixture.kindLabel));
 	return {
-		todos: {
-			snapshot: todos.snapshot,
-			refresh: todos.refresh,
-			async set(sessionId, next) {
-				writeTodos(sessionId, next);
-				return true;
+		plans: {
+			snapshot: plans.snapshot,
+			refresh: plans.refresh,
+			async edit(sessionId, planId, op) {
+				planBackend.edit(sessionId, planId, op);
+			},
+			async control(sessionId, planId, action) {
+				planBackend.control(sessionId, planId, action);
 			},
 			async retry() {}
 		},
@@ -270,9 +260,49 @@ function createFixtureSessionHost(fixture = {}) {
 				for (const [parentId, id] of sides) if (id === sideId) sides.delete(parentId);
 			}
 		} } : {},
+		...fixture.secrets ? { secrets: {
+			entries: secretsState.entries,
+			refresh: secretsState.refresh,
+			async save(sessionId, input) {
+				if (secretsSaveError) throw new Error(secretsSaveError);
+				if (!isSecretName(input.name)) throw new Error(`Invalid secret name: ${input.name}`);
+				const createdAt = Date.now();
+				const entry = {
+					name: input.name,
+					createdAt,
+					expiresAt: fixtureSecretExpiry(input.ttl, createdAt),
+					sessionId
+				};
+				writeSecrets(sessionId, [...(secretLists.get(sessionId) ?? []).filter((e) => e.name !== input.name), entry]);
+				return entry;
+			},
+			async revoke(sessionId, name) {
+				const before = secretLists.get(sessionId) ?? [];
+				const after = before.filter((e) => e.name !== name);
+				writeSecrets(sessionId, after);
+				return after.length < before.length;
+			}
+		} } : {},
+		...fixture.schedules ? { schedules: {
+			status: schedulesState.status,
+			all: schedulesState.all,
+			forSession: schedulesState.forSession,
+			refresh: schedulesState.refresh,
+			ensure: schedulesState.ensure,
+			create: async (input) => scheduleBackend.create(input),
+			update: async (id, patch) => scheduleBackend.update(id, patch),
+			remove: async (id) => scheduleBackend.remove(id),
+			runNow: async (id) => scheduleBackend.runNow(id),
+			fires: async (id, limit) => scheduleBackend.fires(id, limit)
+		} } : {},
 		control: {
+			setSchedules: (list) => scheduleBackend.replace(list),
+			setSchedulesEnabled: (enabled) => scheduleBackend.setEnabled(enabled),
+			setSecrets: writeSecrets,
 			setWork: writeWork,
-			setTodos: writeTodos,
+			writeTodos: planBackend.writeTodos,
+			endRun: planBackend.endRun,
+			setPlans: planBackend.setPlans,
 			setQueue: (sessionId, entries) => writeQueue(sessionId, [...entries]),
 			recordArtifact(sessionId, row) {
 				artifacts.set(sessionId, [row, ...artifacts.get(sessionId) ?? []]);
@@ -281,5 +311,10 @@ function createFixtureSessionHost(fixture = {}) {
 		}
 	};
 }
+const HOUR = 36e5;
+/** When a secret saved at `now` with `ttl` expires, as the backend computes it. */
+function fixtureSecretExpiry(ttl, now) {
+	return ttl === "never" ? null : now + (ttl === "1h" ? HOUR : ttl === "24h" ? 24 * HOUR : 168 * HOUR);
+}
 //#endregion
-export { createFixtureSessionHost, tallyTodos, todosSnapshotOf };
+export { createFixtureSessionHost };

package/dist/session/headless/fixture-plans.d.ts

@@ -0,0 +1,57 @@
+import { PlanControlAction } from "./host.js";
+import { TodoTallyCounts } from "./plans.js";
+import { Plan, PlanEditOp, PlanView, PlansSnapshot, TodoItem, TodoStatus } from "zidane/chat";
+//#region src/session/headless/fixture-plans.d.ts
+/** What a fixture plans backend starts with, per session id. */
+interface FixturePlansSeed {
+  /** Each session's plans, oldest first (`possiblyInterrupted` shows an applying plan with no live run). */
+  plans?: Readonly<Record<string, readonly PlanView[]>>;
+  /** Each session's task list as the agent wrote it (`todowrite`), applied over `plans`: an applying plan. */
+  todos?: Readonly<Record<string, readonly TodoItem[]>>;
+}
+/** A plans backend in memory. */
+interface FixturePlansBackend {
+  /** A session's snapshot, `null` for a session it does not hold. */
+  snapshot(sessionId: string): PlansSnapshot | null;
+  /** A user edit (`plans.edit`). Throws the gate's reason. */
+  edit(sessionId: string, planId: string, op: PlanEditOp): PlansSnapshot;
+  /** A stop or drop (`plans.control`). Throws the gate's reason. */
+  control(sessionId: string, planId: string, action: PlanControlAction): PlansSnapshot;
+  /** The agent's `todowrite`: updates the applying plan, starts one, or resumes a stopped one with the same step ids. */
+  writeTodos(sessionId: string, items: readonly TodoItem[]): void;
+  /** The session's run ended: the plan it applied stops. */
+  endRun(sessionId: string, outcome?: 'completed' | 'aborted' | 'error'): void;
+  /** Replaces a session's plans. */
+  setPlans(sessionId: string, plans: readonly PlanView[]): void;
+  /** Calls `listener` with a session's id after each change. Returns the unsubscribe. */
+  subscribe(listener: (sessionId: string) => void): () => void;
+}
+/**
+ * The snapshot of a session's plans, as the host broadcasts it (every run live: nothing reads as interrupted).
+ *
+ * @param plans - The plans, oldest first.
+ */
+declare function plansSnapshotOf(plans: readonly PlanView[]): PlansSnapshot;
+/**
+ * A session-scope plan over a task list, for fixtures and tests.
+ *
+ * @param items - The steps, as todo items.
+ * @param plan - Fields over the defaults (an applying adhoc plan `plan-1`, untitled).
+ */
+declare function planOf(items: readonly TodoItem[], plan?: Partial<Plan>): Plan;
+/**
+ * Counts todo items by status.
+ *
+ * @param items - The todo list.
+ */
+declare function tallyTodos(items: readonly {
+  status: TodoStatus;
+}[]): TodoTallyCounts;
+/**
+ * Creates a {@link FixturePlansBackend}.
+ *
+ * @param seed - The plans and task lists it starts with.
+ */
+declare function createFixturePlansBackend(seed?: FixturePlansSeed): FixturePlansBackend;
+//#endregion
+export { FixturePlansBackend, FixturePlansSeed, createFixturePlansBackend, planOf, plansSnapshotOf, tallyTodos };

package/dist/session/headless/fixture-plans.js

@@ -0,0 +1,141 @@
+import { SESSION_SCOPE, activePlanSummary, applyPlanEvent } from "zidane/chat/pure";
+//#region src/session/headless/fixture-plans.ts
+const bagOf = (plans) => ({
+	v: 1,
+	plans: [...plans],
+	seen: []
+});
+/**
+* The snapshot of a session's plans, as the host broadcasts it (every run live: nothing reads as interrupted).
+*
+* @param plans - The plans, oldest first.
+*/
+function plansSnapshotOf(plans) {
+	return {
+		plans: [...plans],
+		active: activePlanSummary(bagOf(plans))
+	};
+}
+/**
+* A session-scope plan over a task list, for fixtures and tests.
+*
+* @param items - The steps, as todo items.
+* @param plan - Fields over the defaults (an applying adhoc plan `plan-1`, untitled).
+*/
+function planOf(items, plan = {}) {
+	return {
+		id: "plan-1",
+		scope: SESSION_SCOPE,
+		kind: "adhoc",
+		state: "applying",
+		title: "",
+		revision: 1,
+		createdAt: 1,
+		updatedAt: 1,
+		steps: items.map((item) => ({
+			id: item.id,
+			title: item.content,
+			status: item.status,
+			updatedAt: 1
+		})),
+		...plan
+	};
+}
+/**
+* Counts todo items by status.
+*
+* @param items - The todo list.
+*/
+function tallyTodos(items) {
+	const tally = {
+		pending: 0,
+		in_progress: 0,
+		completed: 0,
+		cancelled: 0
+	};
+	for (const item of items) tally[item.status]++;
+	return tally;
+}
+/**
+* Creates a {@link FixturePlansBackend}.
+*
+* @param seed - The plans and task lists it starts with.
+*/
+function createFixturePlansBackend(seed = {}) {
+	const bags = new Map(Object.entries(seed.plans ?? {}).map(([id, plans]) => [id, bagOf(plans)]));
+	const runs = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let seq = 0;
+	const runId = (sessionId) => `fixture-run-${sessionId}-${runs.get(sessionId) ?? 0}`;
+	const apply = (sessionId, event) => {
+		const result = applyPlanEvent(bags.get(sessionId) ?? bagOf([]), event);
+		if (result.error) throw new Error(result.error);
+		if (result.changed || !bags.has(sessionId)) {
+			bags.set(sessionId, result.bag);
+			for (const listener of listeners) listener(sessionId);
+		}
+		return result.bag;
+	};
+	const writeTodos = (sessionId, items) => {
+		apply(sessionId, {
+			type: "write",
+			id: `write:${++seq}`,
+			at: Date.now(),
+			scope: SESSION_SCOPE,
+			runId: runId(sessionId),
+			items: items.map((item) => ({
+				id: item.id,
+				content: item.content,
+				status: item.status
+			}))
+		});
+	};
+	for (const [sessionId, items] of Object.entries(seed.todos ?? {})) writeTodos(sessionId, items);
+	return {
+		snapshot(sessionId) {
+			const bag = bags.get(sessionId);
+			return bag ? plansSnapshotOf(bag.plans) : null;
+		},
+		edit(sessionId, planId, op) {
+			return plansSnapshotOf(apply(sessionId, {
+				type: "edit",
+				id: `edit:${++seq}`,
+				at: Date.now(),
+				planId,
+				op
+			}).plans);
+		},
+		control(sessionId, planId, action) {
+			const event = {
+				type: "control",
+				id: `control:${++seq}`,
+				at: Date.now(),
+				planId,
+				action
+			};
+			return plansSnapshotOf(apply(sessionId, event).plans);
+		},
+		writeTodos,
+		endRun(sessionId, outcome = "completed") {
+			const id = runId(sessionId);
+			runs.set(sessionId, (runs.get(sessionId) ?? 0) + 1);
+			apply(sessionId, {
+				type: "runEnd",
+				id: `runEnd:${id}`,
+				at: Date.now(),
+				runId: id,
+				outcome
+			});
+		},
+		setPlans(sessionId, plans) {
+			bags.set(sessionId, bagOf(plans));
+			for (const listener of listeners) listener(sessionId);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+//#endregion
+export { createFixturePlansBackend, planOf, plansSnapshotOf, tallyTodos };

package/dist/session/headless/fixture-schedules.d.ts

@@ -0,0 +1,49 @@
+import { SchedulesStatus } from "./host.js";
+import { Schedule, ScheduleFire } from "zidane/chat/pure";
+//#region src/session/headless/fixture-schedules.d.ts
+/** A scripted reminders backend. */
+interface FixtureScheduleBackend {
+  /** `schedules.status`. */
+  status(): SchedulesStatus;
+  /** `schedules.list`: every schedule, or those whose prompt goes to `sessionId`. */
+  list(filter?: {
+    sessionId?: string;
+  }): Schedule[];
+  /** `schedules.create`, as the person (`createdBy: user`). */
+  create(input: unknown): Schedule;
+  /** `schedules.update`. */
+  update(id: string, patch: unknown): Schedule;
+  /** `schedules.delete`: `false` when it was gone. */
+  remove(id: string): boolean;
+  /** `schedules.runNow`: records a fire now; the next time does not move. */
+  runNow(id: string): ScheduleFire;
+  /** `schedules.fires`: newest first. */
+  fires(id: string, limit?: number): ScheduleFire[];
+  /** Replaces the stored schedules from outside (the agent set one, one fired). */
+  replace(list: readonly Schedule[]): void;
+  /** Turns the setting on or off. */
+  setEnabled(enabled: boolean): void;
+  /** Hears every change (`schedules:changed`). Returns the unsubscribe. */
+  subscribe(onChange: (scheduleId?: string) => void): () => void;
+}
+/** What {@link createFixtureScheduleBackend} starts with. */
+interface FixtureScheduleOptions {
+  /** The stored schedules, oldest first. */
+  schedules?: readonly Schedule[];
+  /** Each schedule's fires, newest first. */
+  fires?: Readonly<Record<string, readonly ScheduleFire[]>>;
+  /** `Settings.schedules`. @default true */
+  enabled?: boolean;
+  /** The clock. @default Date.now */
+  now?: () => number;
+}
+/** The message zidane's backend answers while the setting is off. */
+declare const SCHEDULES_OFF_MESSAGE = "Reminders are off. Turn them on in Settings > Sessions > Reminders.";
+/**
+ * Creates a {@link FixtureScheduleBackend}.
+ *
+ * @param options - The starting schedules, fires, setting and clock.
+ */
+declare function createFixtureScheduleBackend(options?: FixtureScheduleOptions): FixtureScheduleBackend;
+//#endregion
+export { FixtureScheduleBackend, FixtureScheduleOptions, SCHEDULES_OFF_MESSAGE, createFixtureScheduleBackend };

package/dist/session/headless/fixture-schedules.js

@@ -0,0 +1,133 @@
+import { defaultCatchUp, nextFireAfter, scheduleTargetSession, validateScheduleInput, validateSchedulePatch } from "zidane/chat/pure";
+//#region src/session/headless/fixture-schedules.ts
+/**
+* Reminders (zidane's schedules) held in memory, as zidane's backend keeps
+* them: the fixture session host's `schedules`, and the scripted backend an
+* app's own `SessionHost` test serves its transport from. Methods answer
+* like the wire methods (`schedules.status`, `.list`, `.create`, `.update`,
+* `.delete`, `.runNow`, `.fires`): they throw the backend's message while
+* the setting is off, and zidane's `ScheduleInputError` for a bad input.
+*/
+/** The message zidane's backend answers while the setting is off. */
+const SCHEDULES_OFF_MESSAGE = "Reminders are off. Turn them on in Settings > Sessions > Reminders.";
+/**
+* Creates a {@link FixtureScheduleBackend}.
+*
+* @param options - The starting schedules, fires, setting and clock.
+*/
+function createFixtureScheduleBackend(options = {}) {
+	const now = options.now ?? Date.now;
+	let list = [...options.schedules ?? []];
+	const fireLists = new Map(Object.entries(options.fires ?? {}).map(([id, fires]) => [id, [...fires]]));
+	let enabled = options.enabled !== false;
+	let seq = 0;
+	const listeners = /* @__PURE__ */ new Set();
+	const changed = (scheduleId) => {
+		for (const l of [...listeners]) l(scheduleId);
+	};
+	const on = () => {
+		if (!enabled) throw new Error(SCHEDULES_OFF_MESSAGE);
+	};
+	const find = (id) => {
+		on();
+		const found = list.find((s) => s.id === id);
+		if (!found) throw new Error(`No schedule "${id}".`);
+		return found;
+	};
+	const write = (next, scheduleId) => {
+		list = next;
+		changed(scheduleId);
+	};
+	return {
+		status: () => ({
+			enabled,
+			supported: true
+		}),
+		list(filter) {
+			on();
+			const sessionId = filter?.sessionId;
+			return sessionId === void 0 ? [...list] : list.filter((s) => scheduleTargetSession(s.action) === sessionId);
+		},
+		create(raw) {
+			on();
+			const at = now();
+			const input = validateScheduleInput(raw, at);
+			const schedule = {
+				id: `fixture-sch${++seq}`,
+				...input.name ? { name: input.name } : {},
+				trigger: input.trigger,
+				action: input.action,
+				catchUp: input.catchUp ?? defaultCatchUp(input.trigger),
+				enabled: input.enabled !== false,
+				createdBy: { kind: "user" },
+				createdAt: at,
+				updatedAt: at,
+				nextFireAt: input.enabled === false ? null : nextFireAfter(input.trigger, at)
+			};
+			write([...list, schedule], schedule.id);
+			return schedule;
+		},
+		update(id, raw) {
+			const found = find(id);
+			const at = now();
+			const { name, expiresAt, ...rest } = validateSchedulePatch(raw, at);
+			const merged = {
+				...found,
+				...rest,
+				updatedAt: at
+			};
+			if (name === null) delete merged.name;
+			else if (name !== void 0) merged.name = name;
+			if (expiresAt === null) delete merged.expiresAt;
+			if (rest.enabled === true) delete merged.disabledReason;
+			merged.nextFireAt = merged.enabled ? nextFireAfter(merged.trigger, at) : null;
+			write(list.map((s) => s.id === id ? merged : s), id);
+			return merged;
+		},
+		remove(id) {
+			on();
+			if (!list.some((s) => s.id === id)) return false;
+			fireLists.delete(id);
+			write(list.filter((s) => s.id !== id), id);
+			return true;
+		},
+		runNow(id) {
+			const found = find(id);
+			const at = now();
+			const target = scheduleTargetSession(found.action);
+			const fire = {
+				id: `fixture-fire${++seq}`,
+				scheduleId: id,
+				dueAt: at,
+				firedAt: at,
+				outcome: found.action.kind === "extension" ? "handled" : "sent",
+				...target ? { sessionId: target } : {}
+			};
+			fireLists.set(id, [fire, ...fireLists.get(id) ?? []]);
+			write(list.map((s) => s.id === id ? {
+				...s,
+				lastFire: fire
+			} : s), id);
+			return fire;
+		},
+		fires(id, limit = 20) {
+			find(id);
+			return (fireLists.get(id) ?? []).slice(0, limit);
+		},
+		replace(next) {
+			write([...next]);
+		},
+		setEnabled(next) {
+			enabled = next;
+			changed();
+		},
+		subscribe(onChange) {
+			listeners.add(onChange);
+			return () => {
+				listeners.delete(onChange);
+			};
+		}
+	};
+}
+//#endregion
+export { SCHEDULES_OFF_MESSAGE, createFixtureScheduleBackend };

package/dist/session/headless/home-layout.d.ts

@@ -8,6 +8,10 @@ interface HomeBlockSource {
   label: string;
   /** The extension that registered it. */
   owner: string;
+  /** That extension's display name. */
+  ownerName?: string;
+  /** That extension's own icon: its mark stands in for a panel without one. */
+  ownerIcon?: PanelIcon;
   /** Its icon. */
   icon?: PanelIcon;
   /** Where it may show; only panels that list `'home'` become blocks. */
@@ -23,6 +27,10 @@ interface HomeBlock {
   label: string;
   /** The extension that registered it. */
   owner: string;
+  /** That extension's display name. */
+  ownerName?: string;
+  /** That extension's own icon: its mark stands in for a block without one. */
+  ownerIcon?: PanelIcon;
   /** Its icon. */
   icon?: PanelIcon;
   /** Shares a row with another half block. */
@@ -124,9 +132,9 @@ declare function showHomeBlock(prefs: HomePrefs, blocks: readonly HomeBlock[], i
  * @param prefs - The arrangement.
  * @param id - The block.
  * @param control - The control id.
- * @param value - The picked option.
+ * @param value - The picked option, or the picked options of a `multi` control.
  */
-declare function setHomeBlockView(prefs: HomePrefs, id: string, control: string, value: string): HomePrefs;
+declare function setHomeBlockView(prefs: HomePrefs, id: string, control: string, value: string | readonly string[]): HomePrefs;
 /**
  * Every project's arrangement from its stored form; `undefined` for anything unrecognised.
  *

package/dist/session/headless/home-layout.js

@@ -21,6 +21,8 @@ function homeBlocksOf(panels) {
 		id: p.id,
 		label: p.label,
 		owner: p.owner,
+		...p.ownerName ? { ownerName: p.ownerName } : {},
+		...p.ownerIcon ? { ownerIcon: p.ownerIcon } : {},
 		...p.icon ? { icon: p.icon } : {},
 		width: p.home?.width === "half" ? "half" : "full"
 	}));
@@ -173,10 +175,11 @@ function showHomeBlock(prefs, blocks, id, defaults) {
 * @param prefs - The arrangement.
 * @param id - The block.
 * @param control - The control id.
-* @param value - The picked option.
+* @param value - The picked option, or the picked options of a `multi` control.
 */
 function setHomeBlockView(prefs, id, control, value) {
-	if (prefs.views[id]?.[control] === value) return prefs;
+	const was = prefs.views[id]?.[control];
+	if (was === value || Array.isArray(was) && Array.isArray(value) && sameList(was, value)) return prefs;
 	return {
 		...prefs,
 		views: {
@@ -189,10 +192,12 @@ function setHomeBlockView(prefs, id, control, value) {
 	};
 }
 const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.length > 0 && x.length <= 512) : [];
+const sameList = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
 function parseView(v) {
 	if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
 	const out = {};
 	for (const [k, value] of Object.entries(v)) if (typeof value === "string") out[k] = value;
+	else if (Array.isArray(value)) out[k] = value.filter((x) => typeof x === "string");
 	return Object.keys(out).length > 0 ? out : void 0;
 }
 /**