@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.0

package/dist/agent/chunks/_commonjsHelpers-ClciMIcB.mjs

@@ -0,0 +1,14 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+export {
+  commonjsGlobal as c,
+  getDefaultExportFromCjs as g
+};

package/dist/agent/chunks/activities-Cj_SIOay.mjs

@@ -0,0 +1,227 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { n as newId } from "./ids-CvnmrMJX.mjs";
+import { p as paginate } from "./query-C5nJB_3C.mjs";
+import { A as ACTIVITY_TYPES } from "../agentcrm.mjs";
+import { assertCan, OpsError, actorId, emit } from "./context-CxFfqS4D.mjs";
+import { r as relationFields, a as relationIds, f as fileTargetPatch, b as fileCleanupMutations } from "./relations-B9TynBmA.mjs";
+import { activitiesOf, recordOf, asDoc, requireActivity, objectsOf, recordsOf, userOf, fileOf } from "./store-5gqRSKXg.mjs";
+import "./fields-B0bitgmr.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+import "./pluginRegistry-DyHtlkcr.mjs";
+function normalizeAttachments(ctx, ids) {
+  const out = [];
+  for (const id of ids ?? []) {
+    const f = fileOf(ctx.store, id);
+    if (!f || f.deletedAt) throw new OpsError("validation", `Attachment "${id}" not found (upload it first).`);
+    if (!out.includes(f.id)) out.push(f.id);
+  }
+  return out;
+}
+function attachmentTargetMutations(ctx, activityId, added, removed) {
+  const out = [];
+  const target = { kind: "activity", id: activityId };
+  for (const id of added) {
+    const f = fileOf(ctx.store, id);
+    const m = f && fileTargetPatch(ctx, f, [target]);
+    if (m) out.push(m);
+  }
+  for (const id of removed) {
+    const f = fileOf(ctx.store, id);
+    const m = f && fileTargetPatch(ctx, f, [], [target]);
+    if (m) out.push(m);
+  }
+  return out;
+}
+function toMs(v) {
+  if (v === null || v === void 0 || v === "") return void 0;
+  if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
+  const t = Date.parse(/^\d{4}-\d{2}-\d{2}$/.test(v) ? `${v}T09:00:00` : v);
+  if (Number.isNaN(t)) throw new OpsError("validation", `Invalid date "${v}".`);
+  return t;
+}
+function normalizeTargets(ctx, targets) {
+  const out = [];
+  for (const t of targets ?? []) {
+    const id = typeof t === "string" ? t : t.id;
+    const r = recordOf(ctx.store, id);
+    if (!r || r.deletedAt) throw new OpsError("validation", `Target record "${id}" not found.`);
+    if (!out.some((x) => x.id === r.id)) out.push({ object: r.object, id: r.id });
+  }
+  return out;
+}
+function checkAssignee(ctx, id) {
+  if (id && !userOf(ctx.store, id)) throw new OpsError("validation", `Unknown assignee "${id}".`);
+}
+function timelineScope(ctx, targetId, includeRelated) {
+  const ids = /* @__PURE__ */ new Set([targetId]);
+  if (!includeRelated) return ids;
+  const target = recordOf(ctx.store, targetId);
+  if (!target) return ids;
+  for (const object of objectsOf(ctx.store)) {
+    for (const field of relationFields(object)) {
+      if (field.relation.object !== target.object) continue;
+      for (const r of recordsOf(ctx.store, object.id)) if (relationIds(r.fields[field.id]).includes(targetId)) ids.add(r.id);
+    }
+  }
+  return ids;
+}
+function listActivities(ctx, opts = {}) {
+  assertCan(ctx, "activities.read");
+  let items = activitiesOf(ctx.store, { includeDeleted: opts.includeDeleted });
+  if (opts.target) {
+    const targetId = typeof opts.target === "string" ? opts.target : opts.target.id;
+    const scope = timelineScope(ctx, targetId, !!opts.includeRelated);
+    items = items.filter((a) => a.targets.some((t) => scope.has(t.id)));
+  }
+  const types = opts.types ?? (opts.type ? [opts.type] : void 0);
+  if (types) items = items.filter((a) => types.includes(a.type));
+  if (opts.assigneeId) items = items.filter((a) => a.assigneeId === opts.assigneeId);
+  if (opts.status === "open") items = items.filter((a) => !a.doneAt);
+  if (opts.status === "done") items = items.filter((a) => !!a.doneAt);
+  if (opts.dueBefore !== void 0) items = items.filter((a) => a.dueAt !== void 0 && a.dueAt < opts.dueBefore);
+  if (opts.dueAfter !== void 0) items = items.filter((a) => a.dueAt !== void 0 && a.dueAt >= opts.dueAfter);
+  if (opts.since !== void 0) items = items.filter((a) => a.createdAt >= opts.since);
+  if (opts.order === "due") {
+    items = [...items].sort((a, b) => (a.dueAt ?? Infinity) - (b.dueAt ?? Infinity) || a.createdAt - b.createdAt);
+  } else {
+    const at = (a) => typeof a.meta?.startAt === "number" ? a.meta.startAt : a.createdAt;
+    items = [...items].sort((a, b) => at(b) - at(a) || (a.id < b.id ? 1 : -1));
+  }
+  return paginate(items, { offset: opts.offset, limit: opts.limit });
+}
+function getActivity(ctx, id) {
+  assertCan(ctx, "activities.read");
+  return requireActivity(ctx.store, id);
+}
+async function addActivity(ctx, input, opts = {}) {
+  assertCan(ctx, "activities.write");
+  if (!ACTIVITY_TYPES.includes(input.type)) throw new OpsError("validation", `Unknown activity type "${input.type}".`);
+  const title = (input.title ?? "").trim() || (input.body ?? "").trim().split("\n")[0].slice(0, 80);
+  if (!title) throw new OpsError("validation", "An activity needs a title.");
+  checkAssignee(ctx, input.assigneeId);
+  const attachments = normalizeAttachments(ctx, input.attachments);
+  const now = ctx.now();
+  const activity = {
+    id: opts.id ?? newId(now),
+    type: input.type,
+    title,
+    ...input.body ? { body: input.body } : {},
+    targets: normalizeTargets(ctx, input.targets),
+    ...toMs(input.dueAt) !== void 0 ? { dueAt: toMs(input.dueAt) } : {},
+    ...input.doneAt ? { doneAt: input.doneAt } : {},
+    ...input.assigneeId ? { assigneeId: input.assigneeId } : input.type === "task" && actorId(ctx) ? { assigneeId: actorId(ctx) } : {},
+    ...input.meta ? { meta: input.meta } : {},
+    ...attachments.length ? { attachments } : {},
+    createdAt: now,
+    updatedAt: now,
+    ...actorId(ctx) ? { createdBy: actorId(ctx) } : {}
+  };
+  await ctx.store.write([{ op: "set", collection: "activities", doc: asDoc(activity) }, ...attachmentTargetMutations(ctx, activity.id, attachments, [])], { message: `Add ${activity.type}` });
+  const stored = requireActivity(ctx.store, activity.id);
+  if (!opts.silent) await emit(ctx, "activity.created", { activity: stored });
+  return stored;
+}
+async function addNote(ctx, target, body, title) {
+  assertCan(ctx, "activities.write");
+  const t = typeof target === "string" ? recordOf(ctx.store, target) : target;
+  if (!t) throw new OpsError("notFound", `Record "${String(target)}" not found.`);
+  return addActivity(ctx, { type: "note", title: title ?? "", body, targets: [{ object: t.object, id: t.id }] });
+}
+function createTask(ctx, input) {
+  return addActivity(ctx, { type: "task", ...input });
+}
+async function updateActivity(ctx, id, patch) {
+  assertCan(ctx, "activities.write");
+  const before = requireActivity(ctx.store, id);
+  const fields = { updatedAt: ctx.now() };
+  if (patch.title !== void 0) {
+    if (!patch.title.trim()) throw new OpsError("validation", "An activity needs a title.");
+    fields.title = patch.title.trim();
+  }
+  if (patch.body !== void 0) fields.body = patch.body || void 0;
+  if (patch.type !== void 0) {
+    if (!ACTIVITY_TYPES.includes(patch.type)) throw new OpsError("validation", `Unknown activity type "${patch.type}".`);
+    fields.type = patch.type;
+  }
+  if (patch.targets !== void 0) fields.targets = normalizeTargets(ctx, patch.targets);
+  if (patch.dueAt !== void 0) fields.dueAt = toMs(patch.dueAt);
+  if (patch.doneAt !== void 0) fields.doneAt = patch.doneAt ?? void 0;
+  if (patch.assigneeId !== void 0) {
+    checkAssignee(ctx, patch.assigneeId);
+    fields.assigneeId = patch.assigneeId ?? void 0;
+  }
+  if (patch.meta !== void 0) for (const [k, v] of Object.entries(patch.meta)) fields[`meta.${k}`] = v;
+  const extra = [];
+  if (patch.attachments !== void 0) {
+    const prev = before.attachments ?? [];
+    const next = normalizeAttachments(ctx, patch.attachments.filter((x) => !prev.includes(x)));
+    const kept = prev.filter((x) => patch.attachments.includes(x));
+    const all = [...kept, ...next];
+    fields.attachments = all.length ? all : void 0;
+    extra.push(...attachmentTargetMutations(ctx, id, next, prev.filter((x) => !all.includes(x))));
+  }
+  await ctx.store.write([{ op: "patch", collection: "activities", id, fields }, ...extra], { message: "Update activity" });
+  const activity = requireActivity(ctx.store, id);
+  await emit(ctx, "activity.updated", { activity, before });
+  if (!before.doneAt && activity.doneAt) await emit(ctx, "activity.completed", { activity });
+  return activity;
+}
+function completeTask(ctx, id, done = true) {
+  return updateActivity(ctx, id, { doneAt: done ? ctx.now() : null });
+}
+async function deleteActivity(ctx, id, opts = {}) {
+  assertCan(ctx, "activities.write");
+  requireActivity(ctx.store, id);
+  await ctx.store.write(
+    opts.hard ? [{ op: "delete", collection: "activities", id }, ...fileCleanupMutations(ctx, { activities: [id] })] : [{ op: "patch", collection: "activities", id, fields: { deletedAt: ctx.now(), updatedAt: ctx.now() } }],
+    { message: "Delete activity" }
+  );
+  return { id };
+}
+function listTasks(ctx, opts = {}) {
+  const now = ctx.now();
+  return listActivities(ctx, {
+    type: "task",
+    assigneeId: opts.assigneeId,
+    status: opts.status ?? "open",
+    target: opts.target,
+    dueBefore: opts.overdue ? now : opts.dueWithinDays !== void 0 ? now + opts.dueWithinDays * 864e5 : void 0,
+    order: "due",
+    limit: opts.limit,
+    offset: opts.offset
+  });
+}
+function lastActivityAt(ctx, recordId) {
+  let max;
+  for (const a of activitiesOf(ctx.store)) {
+    if (!a.targets.some((t) => t.id === recordId)) continue;
+    const at = Math.max(a.createdAt, a.doneAt ?? 0);
+    if (max === void 0 || at > max) max = at;
+  }
+  return max;
+}
+export {
+  addActivity,
+  addNote,
+  completeTask,
+  createTask,
+  deleteActivity,
+  getActivity,
+  lastActivityAt,
+  listActivities,
+  listTasks,
+  timelineScope,
+  updateActivity
+};

package/dist/agent/chunks/api-B6OqNVWp.mjs

@@ -0,0 +1,97 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+const MODULE_CATEGORIES = ["core", "sales", "productivity", "automation", "integrations", "ai", "customisation"];
+function mod(id, m) {
+  return { id, name: `customize:modules.catalog.${id}.name`, description: `customize:modules.catalog.${id}.description`, ...m };
+}
+const BUILTIN_MODULES = [
+  mod("records", { label: "Records", summary: "Objects, records, table & kanban views, record pages.", icon: "Database", category: "core", required: true }),
+  mod("search", { label: "Search", summary: "Cmd+K command palette over records and navigation.", icon: "Search", category: "core", required: true }),
+  mod("settings", { label: "Settings", summary: "Workspace settings, data model, users, import / export.", icon: "Settings", category: "core", required: true }),
+  mod("setup", { label: "Setup & access", summary: "Setup wizard, sign-in, data backend, admin hosting, security.", icon: "ShieldCheck", category: "core", required: true }),
+  mod("dashboard", { label: "Dashboard", summary: "Home dashboard with KPIs, charts and widgets.", icon: "LayoutDashboard", category: "sales" }),
+  mod("deals", { label: "Deals & pipelines", summary: "The deals object, pipelines, kanban board, pipeline reports and widgets.", icon: "Handshake", category: "sales", objects: ["deals"], settingsSection: "pipelines" }),
+  mod("reports", { label: "Reports", summary: "Reports page: pipeline, forecast, won / lost, activity, lead sources.", icon: "BarChart3", category: "sales" }),
+  mod("forms", { label: "Lead forms", summary: "Static lead capture forms and inbox ingestion.", icon: "FileInput", category: "sales" }),
+  mod("tasks", { label: "Tasks", summary: "My tasks / all tasks page and the task overlays.", icon: "CheckSquare", category: "productivity" }),
+  mod("automations", { label: "Automations", summary: "Trigger → conditions → actions workflows and their run log.", icon: "Zap", category: "automation" }),
+  mod("integrations", { label: "Email & calendar", summary: "Gmail, Google Calendar and Outlook sync through browser OAuth.", icon: "Plug", category: "integrations", settingsSection: "integrations" }),
+  mod("assistant", { label: "AI assistant", summary: "Chat panel driving the AI tool catalog with your own Claude API key.", icon: "Sparkles", category: "ai", settingsSection: "assistant" }),
+  mod("customize", { label: "Customisation", summary: "Modules, extensions and appearance settings.", icon: "Palette", category: "customisation", required: true, settingsSection: "modules" })
+];
+function builtinModule(id) {
+  return BUILTIN_MODULES.find((m) => m.id === id);
+}
+const REQUIRED_MODULES = BUILTIN_MODULES.filter((m) => m.required).map((m) => m.id);
+const MODULES_CONFIG_ID = "modules";
+function defaultDisabledModules() {
+  return BUILTIN_MODULES.filter((m) => m.defaultEnabled === false).map((m) => m.id);
+}
+function disabledFromDoc(doc) {
+  const raw = doc && typeof doc === "object" ? doc.disabled : void 0;
+  const list = Array.isArray(raw) ? raw.filter((x) => typeof x === "string") : defaultDisabledModules();
+  return new Set(list.filter((id) => !REQUIRED_MODULES.includes(id)));
+}
+const modules = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BUILTIN_MODULES,
+  MODULES_CONFIG_ID,
+  MODULE_CATEGORIES,
+  REQUIRED_MODULES,
+  builtinModule,
+  defaultDisabledModules,
+  disabledFromDoc
+}, Symbol.toStringTag, { value: "Module" }));
+const EXTENSION_API_VERSION = "1.0.0";
+const EXTENSION_MIN_API_VERSION = "1.0.0";
+const RUNTIME_GLOBAL = "__AGENTCRM_RUNTIME__";
+const RUNTIME_MODULES = {
+  react: "react.js",
+  "react/jsx-runtime": "react-jsx-runtime.js",
+  "react-dom": "react-dom.js",
+  "react-dom/client": "react-dom-client.js",
+  "react-i18next": "react-i18next.js",
+  "lucide-react": "lucide-react.js",
+  "@agent-crm/runtime": "agentcrm-runtime.js"
+};
+const RUNTIME_SPECIFIERS = Object.keys(RUNTIME_MODULES);
+const RUNTIME_DIR = "runtime";
+const EXTENSION_LIMITS = {
+  bundle: 1.5 * 1024 * 1024,
+  style: 256 * 1024,
+  manifest: 16 * 1024,
+  zip: 4 * 1024 * 1024
+};
+function compareVersions(a, b) {
+  const parse = (s) => String(s).split("-")[0].split(".").slice(0, 3).map((p) => Number.parseInt(p, 10) || 0);
+  const x = parse(a);
+  const y = parse(b);
+  for (let i = 0; i < 3; i++) {
+    if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) < (y[i] ?? 0) ? -1 : 1;
+  }
+  return 0;
+}
+function isCompatibleApiVersion(version) {
+  return typeof version === "string" && /^\d+\.\d+\.\d+$/.test(version) && compareVersions(version, EXTENSION_MIN_API_VERSION) >= 0 && compareVersions(version, EXTENSION_API_VERSION) <= 0;
+}
+export {
+  BUILTIN_MODULES as B,
+  EXTENSION_API_VERSION as E,
+  MODULES_CONFIG_ID as M,
+  RUNTIME_SPECIFIERS as R,
+  EXTENSION_LIMITS as a,
+  EXTENSION_MIN_API_VERSION as b,
+  REQUIRED_MODULES as c,
+  disabledFromDoc as d,
+  builtinModule as e,
+  MODULE_CATEGORIES as f,
+  RUNTIME_MODULES as g,
+  RUNTIME_DIR as h,
+  isCompatibleApiVersion as i,
+  RUNTIME_GLOBAL as j,
+  modules as m
+};

package/dist/agent/chunks/appearance-BaShelzt.mjs

@@ -0,0 +1,174 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { m as mixHex, D as DEFAULT_ACCENT, r as resolveAppearance, A as APPEARANCE_DOC_ID, a as DEFAULT_APPEARANCE, v as validateAppearancePatch, b as validateImageDataUrl, c as APPEARANCE_KEYS } from "./schema-7-4-qtSS.mjs";
+import { getExternalTheme } from "./themes-DPZFv3yc.mjs";
+import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+import { extensionDocOf, extensionDocsOf } from "./store-5gqRSKXg.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+function surface(base, lift = 0.45) {
+  return { ...base, 850: mixHex(base[800], base[900], 0.5), 950: mixHex(base[950], base[900], lift) };
+}
+({
+  slate: surface({ 50: "#f8fafc", 100: "#f1f5f9", 200: "#e2e8f0", 300: "#cbd5e1", 400: "#94a3b8", 500: "#64748b", 600: "#475569", 700: "#334155", 800: "#1e293b", 900: "#0f172a", 950: "#020617" }),
+  stone: surface({ 50: "#fafaf9", 100: "#f5f5f4", 200: "#e7e5e4", 300: "#d6d3d1", 400: "#a8a29e", 500: "#78716c", 600: "#57534e", 700: "#44403c", 800: "#292524", 900: "#1c1917", 950: "#0c0a09" }),
+  gray: surface({ 50: "#f9fafb", 100: "#f3f4f6", 200: "#e5e7eb", 300: "#d1d5db", 400: "#9ca3af", 500: "#6b7280", 600: "#4b5563", 700: "#374151", 800: "#1f2937", 900: "#111827", 950: "#030712" }),
+  neutral: surface({ 50: "#fafafa", 100: "#f5f5f5", 200: "#e5e5e5", 300: "#d4d4d4", 400: "#a3a3a3", 500: "#737373", 600: "#525252", 700: "#404040", 800: "#262626", 900: "#171717", 950: "#0a0a0a" })
+});
+const PRESETS = [
+  {
+    id: "default",
+    name: "Default",
+    description: "Neutral grays, blue accent, near-black buttons.",
+    values: { accent: DEFAULT_ACCENT, neutral: "zinc", radius: "md", density: "comfortable", font: "system", sidebar: "default", contrast: "normal", buttons: "neutral" }
+  },
+  {
+    id: "ocean",
+    name: "Ocean",
+    description: "Cool slate grays with a teal-blue accent.",
+    values: { accent: "#0891b2", neutral: "slate", radius: "lg", density: "comfortable", font: "system", sidebar: "default", contrast: "normal", buttons: "accent" }
+  },
+  {
+    id: "forest",
+    name: "Forest",
+    description: "Warm stone grays with a deep green accent and a dark sidebar.",
+    values: { accent: "#16a34a", neutral: "stone", radius: "md", density: "comfortable", font: "system", sidebar: "dark", contrast: "normal", buttons: "accent" }
+  },
+  {
+    id: "sunset",
+    name: "Sunset",
+    description: "Orange accent, soft rounded corners.",
+    values: { accent: "#ea580c", neutral: "stone", radius: "xl", density: "comfortable", font: "system", sidebar: "default", contrast: "normal", buttons: "accent" }
+  },
+  {
+    id: "graphite",
+    name: "Graphite",
+    description: "Monochrome, compact, dark sidebar — dense data work.",
+    values: { accent: "#52525b", neutral: "neutral", radius: "sm", density: "compact", font: "system", sidebar: "dark", contrast: "normal", buttons: "neutral" }
+  },
+  {
+    id: "rose",
+    name: "Rose",
+    description: "Rose accent with a colored sidebar.",
+    values: { accent: "#e11d48", neutral: "zinc", radius: "lg", density: "comfortable", font: "system", sidebar: "accent", contrast: "normal", buttons: "accent" }
+  },
+  {
+    id: "high-contrast",
+    name: "High contrast",
+    description: "Stronger borders and text, square corners — accessibility first.",
+    values: { accent: "#1d4ed8", neutral: "gray", radius: "sm", density: "comfortable", font: "system", sidebar: "default", contrast: "high", buttons: "neutral" }
+  }
+];
+function findPreset(id) {
+  return PRESETS.find((p) => p.id === id);
+}
+const BRANDING_KEYS = ["logo", "favicon", "customCss"];
+function getAppearanceDoc(ctx) {
+  assertCan(ctx, "settings.read");
+  return ctx.store.get("config", APPEARANCE_DOC_ID);
+}
+function getAppearance(ctx) {
+  const doc = getAppearanceDoc(ctx);
+  const theme = doc?.themeId && extensionDocOf(ctx.store, doc.themeId)?.enabled ? getExternalTheme(doc.themeId) : void 0;
+  return resolveAppearance(doc, theme);
+}
+function explicit(doc) {
+  if (!doc) return {};
+  return Object.fromEntries(Object.entries(doc).filter(([k, v]) => APPEARANCE_KEYS.includes(k) && v !== void 0));
+}
+async function writeDoc(ctx, values, message) {
+  const doc = { ...values, id: APPEARANCE_DOC_ID, updatedAt: ctx.now(), ...ctx.user?.id ? { updatedBy: ctx.user.id } : {} };
+  await ctx.store.write([{ op: "set", collection: "config", doc }], { message });
+  return getAppearance(ctx);
+}
+function assertTheme(ctx, id) {
+  const ext = extensionDocOf(ctx.store, id);
+  if (!ext || ext.kind !== "theme") {
+    const themes = extensionDocsOf(ctx.store).filter((d) => d.kind === "theme").map((d) => d.id);
+    throw new OpsError("notFound", `Theme "${id}" is not installed.${themes.length ? ` Installed themes: ${themes.join(", ")}.` : ""}`);
+  }
+  if (!ext.enabled) throw new OpsError("invalid", `Theme "${id}" is disabled — enable it first.`);
+}
+async function setAppearance(ctx, patch) {
+  assertCan(ctx, "appearance.write");
+  const { value, errors } = validateAppearancePatch(patch);
+  if (errors.length) throw new OpsError("validation", errors.join(" "), errors);
+  if (typeof value.themeId === "string") assertTheme(ctx, value.themeId);
+  if (typeof value.preset === "string" && value.preset !== "custom" && !findPreset(value.preset) && value.preset !== value.themeId && !extensionDocOf(ctx.store, value.preset)) {
+    throw new OpsError("validation", `Unknown preset "${value.preset}". Presets: ${PRESETS.map((p) => p.id).join(", ")}, custom.`);
+  }
+  const next = { ...explicit(getAppearanceDoc(ctx)) };
+  for (const [k, v] of Object.entries(value)) {
+    if (v === void 0) delete next[k];
+    else next[k] = v;
+  }
+  const visual = Object.keys(value).some((k) => !BRANDING_KEYS.includes(k) && k !== "preset" && k !== "defaultMode" && k !== "themeId");
+  if (visual && value.preset === void 0) next.preset = "custom";
+  return writeDoc(ctx, next, "Update appearance");
+}
+async function applyPreset(ctx, id) {
+  assertCan(ctx, "appearance.write");
+  const current = explicit(getAppearanceDoc(ctx));
+  const kept = {};
+  for (const k of BRANDING_KEYS) if (current[k] !== void 0) kept[k] = current[k];
+  const preset = findPreset(id);
+  if (preset) {
+    return writeDoc(ctx, { ...kept, ...current.defaultMode ? { defaultMode: current.defaultMode } : {}, ...preset.values, preset: preset.id }, `Apply appearance preset ${preset.name}`);
+  }
+  const ext = extensionDocOf(ctx.store, id);
+  if (ext?.kind === "theme") {
+    assertTheme(ctx, id);
+    return writeDoc(ctx, { ...kept, preset: id, themeId: id }, `Apply theme ${ext.manifest.name}`);
+  }
+  const themes = extensionDocsOf(ctx.store).filter((d) => d.kind === "theme").map((d) => d.id);
+  throw new OpsError("notFound", `Unknown preset "${id}". Presets: ${[...PRESETS.map((p) => p.id), ...themes].join(", ")}.`);
+}
+async function resetAppearance(ctx, opts = {}) {
+  assertCan(ctx, "appearance.write");
+  const current = explicit(getAppearanceDoc(ctx));
+  const kept = opts.branding ? {} : { ...current.logo ? { logo: current.logo } : {}, ...current.favicon ? { favicon: current.favicon } : {} };
+  if (!Object.keys(kept).length) {
+    if (getAppearanceDoc(ctx)) await ctx.store.write([{ op: "delete", collection: "config", id: APPEARANCE_DOC_ID }], { message: "Reset appearance" });
+    return getAppearance(ctx);
+  }
+  return writeDoc(ctx, kept, "Reset appearance");
+}
+async function setLogo(ctx, dataUrl, opts = {}) {
+  assertCan(ctx, "appearance.write");
+  const kind = opts.kind ?? "logo";
+  if (dataUrl !== null) {
+    const err = validateImageDataUrl(dataUrl, kind);
+    if (err) throw new OpsError("validation", err);
+  }
+  return setAppearance(ctx, { [kind]: dataUrl });
+}
+function listPresets(ctx) {
+  assertCan(ctx, "settings.read");
+  const builtin = PRESETS.map((p) => ({ id: p.id, name: p.name, description: p.description, source: "builtin", values: { ...DEFAULT_APPEARANCE, ...p.values, preset: p.id } }));
+  const themes = extensionDocsOf(ctx.store).filter((d) => d.kind === "theme").map((d) => {
+    const loaded = getExternalTheme(d.id);
+    return {
+      id: d.id,
+      name: loaded?.name ?? d.manifest.name,
+      description: loaded?.description ?? d.manifest.description,
+      source: "extension",
+      values: loaded ? { ...DEFAULT_APPEARANCE, ...loaded.appearance, preset: d.id, themeId: d.id } : { themeId: d.id },
+      enabled: !!d.enabled,
+      loaded: !!loaded,
+      version: d.manifest.version
+    };
+  });
+  return [...builtin, ...themes];
+}
+export {
+  applyPreset,
+  getAppearance,
+  getAppearanceDoc,
+  listPresets,
+  resetAppearance,
+  setAppearance,
+  setLogo
+};