dsh-claude-desktop-theme 0.2.0

package/lib/index.js

@@ -0,0 +1,666 @@
+// src/host/index.ts
+import z from "@deepseek-ai/schemastery";
+
+// src/shared/config.ts
+var DEFAULT_FEATURES = Object.freeze({
+  shell: true,
+  sidebar: true,
+  "new-session": true,
+  conversation: true,
+  "tool-calls": false,
+  statistics: false,
+  "composer-pet": true
+});
+var DEFAULT_APPEARANCE = Object.freeze({
+  canvas: "",
+  sidebar: ""
+});
+var DEFAULT_FONTS = Object.freeze({
+  uiLatin: "",
+  uiCjk: "",
+  code: ""
+});
+var FONT_NAME_MAX_LENGTH = 64;
+
+// src/shared/stats.ts
+var STATS_PATH = "/api/ccd-stats";
+var STATS_VERSION = 2;
+var STATS_DAY_LIMIT = 366;
+var STATS_RANGES = ["all", "30d", "7d"];
+var STATS_RANGE_DAYS = {
+  all: null,
+  "30d": 30,
+  "7d": 7
+};
+function localDayKey(time) {
+  const date = new Date(time);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+function rangeStart(range, now) {
+  const days = STATS_RANGE_DAYS[range];
+  if (days === null) return null;
+  const date = new Date(now);
+  date.setHours(0, 0, 0, 0);
+  date.setDate(date.getDate() - (days - 1));
+  return localDayKey(date.getTime());
+}
+
+// src/shared/identity.ts
+var PLUGIN_ID = "dsh-claude-desktop-theme";
+
+// src/host/stats/unit.ts
+var USAGE_KEY = "ccdUsage";
+var USAGE_STATE_VERSION = 2;
+var UNKNOWN_MODEL = "unknown";
+var HOURS_PER_DAY = 24;
+function rawTokens(usage) {
+  const total = usage.totalTokens;
+  if (typeof total === "number" && Number.isFinite(total) && total > 0) return total;
+  const sum = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+  return Number.isFinite(sum) && sum > 0 ? sum : 0;
+}
+function counter(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function initUsageState(_header, inheritedEventCount) {
+  return {
+    seedSeq: inheritedEventCount,
+    prompts: 0,
+    tokens: 0,
+    days: {},
+    hours: new Array(HOURS_PER_DAY).fill(0),
+    models: {},
+    modelDays: {},
+    model: null
+  };
+}
+function bumped(record, key, amount) {
+  return { ...record, [key]: (record[key] ?? 0) + amount };
+}
+function applyUsageEvent(state, event) {
+  if (event.seq < state.seedSeq) return state;
+  if (event.type === "user/message") {
+    if (event.data.source.kind !== "user") return state;
+    const hour = new Date(event.time).getHours();
+    const hours = state.hours.slice();
+    hours[hour] = (hours[hour] ?? 0) + 1;
+    return {
+      ...state,
+      prompts: state.prompts + 1,
+      days: bumped(state.days, localDayKey(event.time), 1),
+      hours
+    };
+  }
+  if (event.type === "assistant/message") {
+    const usage = event.data.usage;
+    if (usage === void 0) return state;
+    const added = rawTokens(usage);
+    if (added === 0) return state;
+    const model = state.model ?? UNKNOWN_MODEL;
+    const day = localDayKey(event.time);
+    const previous = state.models[model] ?? { t: 0, i: 0, o: 0 };
+    return {
+      ...state,
+      tokens: state.tokens + added,
+      models: {
+        ...state.models,
+        [model]: {
+          t: previous.t + added,
+          i: previous.i + counter(usage.inputTokens),
+          o: previous.o + counter(usage.outputTokens)
+        }
+      },
+      modelDays: {
+        ...state.modelDays,
+        [day]: bumped(state.modelDays[day] ?? {}, model, added)
+      }
+    };
+  }
+  if (event.type === "request/header") {
+    const config = event.data.header.config;
+    const model = `${config.provider}/${config.model}`;
+    return model === state.model ? state : { ...state, model };
+  }
+  return state;
+}
+function pairs(record) {
+  return Object.entries(record).filter(([, count2]) => count2 > 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+}
+function hourPairs(hours) {
+  const sparse = [];
+  for (let hour = 0; hour < hours.length; hour += 1) {
+    const count2 = hours[hour] ?? 0;
+    if (count2 > 0) sparse.push([hour, count2]);
+  }
+  return sparse;
+}
+function modelPairs(models) {
+  return Object.entries(models).filter(([, usage]) => usage.t > 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([model, usage]) => [model, usage.t, usage.i, usage.o]);
+}
+function modelDayRows(modelDays, table) {
+  const index = new Map(table.map(([model], at) => [model, at]));
+  const rows = [];
+  for (const day of Object.keys(modelDays).sort()) {
+    const perModel = modelDays[day] ?? {};
+    for (const model of Object.keys(perModel).sort()) {
+      const at = index.get(model);
+      const tokens = perModel[model] ?? 0;
+      if (at === void 0 || tokens <= 0) continue;
+      rows.push([day, at, tokens]);
+    }
+  }
+  return rows;
+}
+var views = /* @__PURE__ */ new WeakMap();
+function viewUsage(state) {
+  const cached = views.get(state);
+  if (cached !== void 0) return cached;
+  const models = modelPairs(state.models);
+  const view = {
+    prompts: state.prompts,
+    tokens: state.tokens,
+    days: pairs(state.days),
+    hours: hourPairs(state.hours),
+    models,
+    modelDays: modelDayRows(state.modelDays, models)
+  };
+  views.set(state, view);
+  return view;
+}
+function schemaOf(parse) {
+  return { parse };
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function readCounts(value) {
+  const counts = {};
+  if (typeof value !== "object" || value === null) return counts;
+  for (const [key, entry] of Object.entries(value)) {
+    const parsed = count(entry);
+    if (parsed > 0) counts[key] = parsed;
+  }
+  return counts;
+}
+function readModels(value) {
+  const models = {};
+  if (typeof value !== "object" || value === null) return models;
+  for (const [model, entry] of Object.entries(value)) {
+    if (typeof entry === "number") {
+      const total2 = count(entry);
+      if (total2 > 0) models[model] = { t: total2, i: 0, o: 0 };
+      continue;
+    }
+    if (typeof entry !== "object" || entry === null) continue;
+    const raw = entry;
+    const total = count(raw["t"]);
+    if (total > 0) models[model] = { t: total, i: count(raw["i"]), o: count(raw["o"]) };
+  }
+  return models;
+}
+function readModelDays(value) {
+  const days = {};
+  if (typeof value !== "object" || value === null) return days;
+  for (const [day, entry] of Object.entries(value)) {
+    const perModel = readCounts(entry);
+    if (Object.keys(perModel).length > 0) days[day] = perModel;
+  }
+  return days;
+}
+function readUsageState(value) {
+  const raw = typeof value === "object" && value !== null ? value : {};
+  const hours = new Array(HOURS_PER_DAY).fill(0);
+  const rawHours = Array.isArray(raw["hours"]) ? raw["hours"] : [];
+  for (let hour = 0; hour < HOURS_PER_DAY; hour += 1) hours[hour] = count(rawHours[hour]);
+  const model = raw["model"];
+  return {
+    seedSeq: count(raw["seedSeq"]),
+    prompts: count(raw["prompts"]),
+    tokens: count(raw["tokens"]),
+    days: readCounts(raw["days"]),
+    hours,
+    models: readModels(raw["models"]),
+    modelDays: readModelDays(raw["modelDays"]),
+    model: typeof model === "string" && model !== "" ? model : null
+  };
+}
+function readPairList(value, key) {
+  if (!Array.isArray(value)) return [];
+  const list = [];
+  for (const entry of value) {
+    if (!Array.isArray(entry) || entry.length !== 2) continue;
+    const [rawKey, rawCount] = entry;
+    const parsedKey = key(rawKey);
+    const parsedCount = count(rawCount);
+    if (parsedKey === null || parsedCount === 0) continue;
+    list.push([parsedKey, parsedCount]);
+  }
+  return list;
+}
+function readUsageView(value) {
+  const raw = typeof value === "object" && value !== null ? value : {};
+  const models = [];
+  if (Array.isArray(raw["models"])) {
+    for (const entry of raw["models"]) {
+      if (!Array.isArray(entry) || entry.length < 4) continue;
+      const [model, total, input, output] = entry;
+      if (typeof model !== "string" || model === "") continue;
+      const tokens = count(total);
+      if (tokens === 0) continue;
+      models.push([model, tokens, count(input), count(output)]);
+    }
+  }
+  const modelDays = [];
+  if (Array.isArray(raw["modelDays"])) {
+    for (const entry of raw["modelDays"]) {
+      if (!Array.isArray(entry) || entry.length !== 3) continue;
+      const [day, at, tokens] = entry;
+      if (typeof day !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+      if (typeof at !== "number" || !Number.isInteger(at) || at < 0 || at >= models.length) continue;
+      const counted = count(tokens);
+      if (counted === 0) continue;
+      modelDays.push([day, at, counted]);
+    }
+  }
+  return {
+    prompts: count(raw["prompts"]),
+    tokens: count(raw["tokens"]),
+    days: readPairList(raw["days"], (rawKey) => typeof rawKey === "string" && /^\d{4}-\d{2}-\d{2}$/.test(rawKey) ? rawKey : null),
+    /* Hour keys travel as numbers; a string is accepted for a hand-written row. */
+    hours: readPairList(raw["hours"], (rawKey) => {
+      const hour = typeof rawKey === "number" ? rawKey : Number(rawKey);
+      return Number.isInteger(hour) && hour >= 0 && hour < HOURS_PER_DAY ? hour : null;
+    }),
+    models,
+    modelDays
+  };
+}
+var usageProjection = {
+  key: USAGE_KEY,
+  stateSchema: schemaOf(readUsageState),
+  init: initUsageState,
+  apply: applyUsageEvent,
+  wire: {
+    viewSchema: schemaOf(readUsageView),
+    view: viewUsage
+  },
+  stateVersion: USAGE_STATE_VERSION
+};
+
+// src/host/stats/aggregate.ts
+var byKey = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var byTokens = (left, right) => right[1] - left[1] || byKey(left[0], right[0]);
+function peak(counts, skip) {
+  let best = null;
+  let bestCount = 0;
+  for (const [key, count2] of counts) {
+    if (key === skip || count2 <= 0) continue;
+    if (count2 > bestCount || count2 === bestCount && best !== null && key < best) {
+      best = key;
+      bestCount = count2;
+    }
+  }
+  return best;
+}
+function collect(value, collected) {
+  if (value.prompts <= 0 && value.tokens <= 0) return;
+  const dates = /* @__PURE__ */ new Set();
+  for (const [date, count2] of value.days) {
+    dates.add(date);
+    collected.prompts.set(date, (collected.prompts.get(date) ?? 0) + count2);
+  }
+  for (const [hour, count2] of value.hours) collected.hours.set(hour, (collected.hours.get(hour) ?? 0) + count2);
+  for (const [model, tokens, input, output] of value.models) {
+    const previous = collected.modelUsage.get(model) ?? { t: 0, i: 0, o: 0 };
+    collected.modelUsage.set(model, {
+      t: previous.t + tokens,
+      i: previous.i + input,
+      o: previous.o + output
+    });
+  }
+  for (const [date, at, tokens] of value.modelDays) {
+    const model = value.models[at]?.[0];
+    if (model === void 0) continue;
+    dates.add(date);
+    const perModel = collected.modelDays.get(date) ?? /* @__PURE__ */ new Map();
+    perModel.set(model, (perModel.get(model) ?? 0) + tokens);
+    collected.modelDays.set(date, perModel);
+  }
+  collected.sessionDates.push(dates);
+}
+function totalsFor(collected, start) {
+  const inRange = (date) => start === null || date >= start;
+  let sessions = 0;
+  for (const dates of collected.sessionDates) {
+    for (const date of dates) {
+      if (!inRange(date)) continue;
+      sessions += 1;
+      break;
+    }
+  }
+  const active = /* @__PURE__ */ new Set();
+  let messages = 0;
+  for (const [date, count2] of collected.prompts) {
+    if (!inRange(date)) continue;
+    messages += count2;
+    active.add(date);
+  }
+  const models = /* @__PURE__ */ new Map();
+  let tokens = 0;
+  for (const [date, perModel] of collected.modelDays) {
+    if (!inRange(date)) continue;
+    active.add(date);
+    for (const [model, amount] of perModel) {
+      tokens += amount;
+      models.set(model, (models.get(model) ?? 0) + amount);
+    }
+  }
+  const list = [...models.entries()].filter(([model, amount]) => model !== UNKNOWN_MODEL && amount > 0).sort(byTokens);
+  return {
+    sessions,
+    messages,
+    tokens,
+    activeDays: active.size,
+    topModel: peak(models, UNKNOWN_MODEL),
+    models: list
+  };
+}
+function aggregateUsage(values, options) {
+  const collected = {
+    sessionDates: [],
+    prompts: /* @__PURE__ */ new Map(),
+    hours: /* @__PURE__ */ new Map(),
+    modelUsage: /* @__PURE__ */ new Map(),
+    modelDays: /* @__PURE__ */ new Map()
+  };
+  for (const value of values) collect(value, collected);
+  const ranges = {};
+  for (const range of STATS_RANGES) ranges[range] = totalsFor(collected, rangeStart(range, options.now));
+  const dates = [.../* @__PURE__ */ new Set([...collected.prompts.keys(), ...collected.modelDays.keys()])].sort(byKey);
+  const cutoff = dates.length > STATS_DAY_LIMIT ? dates[dates.length - STATS_DAY_LIMIT] ?? null : null;
+  const days = [];
+  for (const date of dates) {
+    if (cutoff !== null && date < cutoff) continue;
+    const count2 = collected.prompts.get(date) ?? 0;
+    if (count2 > 0) days.push([date, count2]);
+  }
+  const modelDays = [];
+  for (const [date, perModel] of [...collected.modelDays.entries()].sort(([left], [right]) => byKey(left, right))) {
+    if (cutoff !== null && date < cutoff) continue;
+    for (const [model, tokens] of [...perModel.entries()].sort(([left], [right]) => byKey(left, right))) {
+      if (tokens > 0) modelDays.push([date, model, tokens]);
+    }
+  }
+  const modelIO = [...collected.modelUsage.entries()].filter(([model, usage]) => model !== UNKNOWN_MODEL && usage.t > 0).sort(([left], [right]) => byKey(left, right)).map(([model, usage]) => [model, usage.i, usage.o]);
+  let busyHour = null;
+  let busyCount = 0;
+  for (let hour = 0; hour < HOURS_PER_DAY; hour += 1) {
+    const count2 = collected.hours.get(hour) ?? 0;
+    if (count2 > busyCount) {
+      busyHour = hour;
+      busyCount = count2;
+    }
+  }
+  return {
+    version: STATS_VERSION,
+    ranges,
+    busyHour,
+    days,
+    modelDays,
+    modelIO,
+    pending: options.pending,
+    missed: options.missed,
+    computedAt: options.now
+  };
+}
+
+// src/host/stats/service.ts
+var FOLD_CONCURRENCY = 4;
+var RETRY_COOLDOWN_MS = 6e4;
+var UsageAggregator = class {
+  ctx;
+  warn;
+  values = /* @__PURE__ */ new Map();
+  queued = [];
+  folding = /* @__PURE__ */ new Set();
+  failures = /* @__PURE__ */ new Map();
+  running = 0;
+  refreshRun = null;
+  snapshot = null;
+  disposed = false;
+  constructor(ctx, warn) {
+    this.ctx = ctx;
+    this.warn = warn;
+  }
+  /** The most recent snapshot; an empty one before the first refresh. */
+  get current() {
+    return this.snapshot ?? aggregateUsage([], { now: Date.now(), pending: 0, missed: 0 });
+  }
+  /**
+   * Bring the snapshot up to date.
+   *
+   * The listing pass is cheap (projection reads only) and serialized, so
+   * several polling browsers share one pass; cold folds continue in the
+   * background and land in later snapshots.
+   *
+   * @returns the snapshot as of this pass.
+   */
+  refresh() {
+    const running = this.refreshRun;
+    if (running !== null) return running;
+    const run = this.pass().finally(() => {
+      if (this.refreshRun === run) this.refreshRun = null;
+    });
+    this.refreshRun = run;
+    return run;
+  }
+  /** Stop folding; in-flight reads settle but no longer publish. */
+  dispose() {
+    this.disposed = true;
+    this.queued.length = 0;
+  }
+  async pass() {
+    try {
+      const candidates = await this.list();
+      const listed = new Set(candidates.map((candidate) => candidate.header.id));
+      for (const id of [...this.values.keys()]) if (!listed.has(id)) this.values.delete(id);
+      for (const id of [...this.failures.keys()]) if (!listed.has(id)) this.failures.delete(id);
+      for (const candidate of candidates) {
+        if (this.disposed) break;
+        const value = this.readSafely(candidate);
+        if (value === void 0) this.enqueue(candidate);
+        else this.values.set(candidate.header.id, value);
+      }
+    } catch (error) {
+      this.warn("session listing failed; the card keeps the last snapshot", error);
+    }
+    this.publish();
+    return this.current;
+  }
+  /** Every stored session the card counts, newest first. */
+  async list() {
+    const query = this.ctx.get("sessionQuery");
+    if (query !== void 0) {
+      const records = await query.listSessions();
+      return records.filter((record) => record.header.cwd !== void 0).map((record) => ({ header: record.header, live: record.live }));
+    }
+    const persistence = this.ctx.get("sessionPersistence");
+    if (persistence === void 0) return [];
+    const snapshots = await persistence.list();
+    return snapshots.filter((snapshot) => snapshot.header.cwd !== void 0).map((snapshot) => ({ header: snapshot.header, live: false }));
+  }
+  /**
+   * Read one session's value without letting a single failure drop the pass.
+   *
+   * A live session's projection read can throw (a host-side projection bug, a
+   * log the registry cannot advance across); that must cost this session's
+   * numbers, not every session's.
+   */
+  readSafely(candidate) {
+    try {
+      return this.read(candidate);
+    } catch (error) {
+      this.warn(`projection read failed for session ${candidate.header.id}`, error);
+      return void 0;
+    }
+  }
+  /** Zero-I/O read: the live registry for a live session, the durable cache for a cold one. */
+  read(candidate) {
+    const projections = this.ctx.get("sessionProjections");
+    if (projections === void 0) return void 0;
+    if (candidate.live) {
+      const session = this.ctx.get("sessions")?.get(candidate.header.id);
+      if (session !== void 0) {
+        return projections.snapshot(session, [USAGE_KEY]).values[USAGE_KEY];
+      }
+    }
+    const cache = this.ctx.get("sessionProjectionCache");
+    return cache?.cachedSnapshot(candidate.header, [USAGE_KEY])?.values[USAGE_KEY];
+  }
+  /** Queue one cold fold unless it is already queued, running, or cooling down. */
+  enqueue(candidate) {
+    const id = candidate.header.id;
+    if (this.folding.has(id) || this.queued.some((entry) => entry.header.id === id)) return;
+    const failedAt = this.failures.get(id);
+    if (failedAt !== void 0 && Date.now() - failedAt < RETRY_COOLDOWN_MS) return;
+    this.queued.push(candidate);
+    this.pump();
+  }
+  /** Keep at most {@link FOLD_CONCURRENCY} folds in flight. */
+  pump() {
+    while (!this.disposed && this.running < FOLD_CONCURRENCY) {
+      const candidate = this.queued.shift();
+      if (candidate === void 0) return;
+      const id = candidate.header.id;
+      this.folding.add(id);
+      this.running += 1;
+      void this.fold(candidate).finally(() => {
+        this.folding.delete(id);
+        this.running -= 1;
+        this.publish();
+        this.pump();
+      });
+    }
+  }
+  /** Fold one cold session once, refreshing its durable checkpoint. */
+  async fold(candidate) {
+    const persistence = this.ctx.get("sessionPersistence");
+    const cache = this.ctx.get("sessionProjectionCache");
+    if (persistence === void 0 || cache === void 0) return;
+    let handle;
+    try {
+      handle = await persistence.open(candidate.header.id, "read");
+      const { events } = await handle.read(0);
+      const block = cache.coldSnapshot(handle.header, handle.inheritedEventCount, events);
+      const value = block.values[USAGE_KEY];
+      if (this.disposed) return;
+      if (value === void 0) {
+        this.failures.set(candidate.header.id, Date.now());
+        return;
+      }
+      this.values.set(candidate.header.id, value);
+      this.failures.delete(candidate.header.id);
+    } catch (error) {
+      this.failures.set(candidate.header.id, Date.now());
+      this.warn(`fold failed for session ${candidate.header.id}`, error);
+    } finally {
+      if (handle !== void 0) {
+        try {
+          await handle.close();
+        } catch {
+        }
+      }
+    }
+  }
+  /** Recompute the snapshot from the values read so far. */
+  publish() {
+    if (this.disposed) return;
+    this.snapshot = aggregateUsage(this.values.values(), {
+      now: Date.now(),
+      pending: this.queued.length + this.running,
+      missed: this.failures.size
+    });
+  }
+};
+function mountStatistics(ctx, isEnabled) {
+  ctx.inject(["sessionProjections", "connection"], (injected) => {
+    if (!isEnabled()) return;
+    const projections = injected.get("sessionProjections");
+    const routes = injected.get("connection");
+    if (projections === void 0 || routes === void 0) return;
+    const warn = (message, error) => {
+      try {
+        console.warn(`[${PLUGIN_ID}] statistics: ${message}`, error);
+      } catch {
+      }
+    };
+    projections.register(usageProjection);
+    const aggregator = new UsageAggregator(injected, warn);
+    ctx.effect(() => routes.fetch.register({
+      path: STATS_PATH,
+      methods: ["GET"],
+      requestBody: "buffered",
+      fetch: async () => {
+        const snapshot = await aggregator.refresh();
+        return new Response(JSON.stringify(snapshot), {
+          headers: {
+            "content-type": "application/json; charset=utf-8",
+            "cache-control": "no-store"
+          }
+        });
+      }
+    }), "statistics: snapshot route");
+    ctx.effect(() => () => aggregator.dispose(), "statistics: aggregation");
+  });
+}
+
+// src/host/index.ts
+var HEX_COLOUR = /^(#[0-9a-fA-F]{3}|#[0-9a-fA-F]{6})?$/;
+var FONT_NAME = new RegExp(`^[\\p{L}\\p{N} ._-]{0,${FONT_NAME_MAX_LENGTH}}$`, "u");
+var Config = z.object({
+  enabled: z.boolean().default(false).description("\u542F\u7528 CCD \u98CE\u683C\u754C\u9762").volatile(),
+  debug: z.boolean().default(false).description("\u5728\u63A7\u5236\u53F0\u8F93\u51FA\u8C03\u8BD5\u65E5\u5FD7").volatile(),
+  features: z.object({
+    shell: z.boolean().default(DEFAULT_FEATURES.shell),
+    sidebar: z.boolean().default(DEFAULT_FEATURES.sidebar),
+    "new-session": z.boolean().default(DEFAULT_FEATURES["new-session"]),
+    conversation: z.boolean().default(DEFAULT_FEATURES.conversation),
+    "tool-calls": z.boolean().default(DEFAULT_FEATURES["tool-calls"]),
+    statistics: z.boolean().default(DEFAULT_FEATURES.statistics),
+    "composer-pet": z.boolean().default(DEFAULT_FEATURES["composer-pet"])
+  }).default({ ...DEFAULT_FEATURES }).description("\u6309\u6A21\u5757\u542F\u7528").volatile(),
+  /* One volatile node per section, exactly like `features`: Cordis rejects a
+     volatile field nested inside another volatile field ("volatile fields
+     require a fixed object path without an enclosing volatile field"), and a
+     volatile object already makes its whole subtree editable. */
+  appearance: z.object({
+    canvas: z.string().default(DEFAULT_APPEARANCE.canvas).description("\u4F1A\u8BDD\u4E0E\u753B\u5E03\u80CC\u666F\u8272\uFF08#rrggbb\uFF0C\u7559\u7A7A\u7528\u5185\u7F6E\u503C\uFF09").pattern(HEX_COLOUR),
+    sidebar: z.string().default(DEFAULT_APPEARANCE.sidebar).description("\u4FA7\u680F\u80CC\u666F\u8272\uFF08#rrggbb\uFF0C\u7559\u7A7A\u7528\u5185\u7F6E\u503C\uFF09").pattern(HEX_COLOUR)
+  }).default({ ...DEFAULT_APPEARANCE }).description("\u80CC\u666F\u8272").volatile(),
+  fonts: z.object({
+    uiLatin: z.string().default(DEFAULT_FONTS.uiLatin).description("\u754C\u9762\u897F\u6587\u5B57\u4F53\u540D\uFF08\u7559\u7A7A\u7528\u7CFB\u7EDF\u6808\uFF09").pattern(FONT_NAME),
+    uiCjk: z.string().default(DEFAULT_FONTS.uiCjk).description("\u754C\u9762\u4E2D\u6587\u5B57\u4F53\u540D\uFF08\u7559\u7A7A\u7528\u7CFB\u7EDF\u6808\uFF09").pattern(FONT_NAME),
+    code: z.string().default(DEFAULT_FONTS.code).description("\u4EE3\u7801\u4E0E\u7B49\u5BBD\u5B57\u4F53\u540D\uFF08\u7559\u7A7A\u7528\u7CFB\u7EDF\u6808\uFF09").pattern(FONT_NAME)
+  }).default({ ...DEFAULT_FONTS }).description("\u5B57\u4F53").volatile()
+});
+function readValue(node, fallback) {
+  if (node === void 0) return fallback;
+  if (typeof node === "object" && node !== null && typeof node.get === "function") {
+    try {
+      return node.get();
+    } catch {
+      return fallback;
+    }
+  }
+  return node;
+}
+function apply(ctx, config) {
+  const host = typeof config === "object" && config !== null ? config : {};
+  mountStatistics(ctx, () => readValue(host.enabled, false) === true);
+}
+export {
+  Config,
+  apply
+};

package/lib/types/client/apply.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Cordis services, not manifest package-name edges, control activation.
+ *
+ * `sessions` is the Session Controller's catalog store: the sidebar column
+ * reads its `blank` flag to keep a provisional New Session row out of the list.
+ * It is a prerequisite of `uiWorkspace` already, and Cordis refuses to resolve
+ * a service that is not declared here, so the dependency is named rather than
+ * discovered at the point of use.
+ */
+export declare const inject: string[];
+/**
+ * The only assembly point allowed to import multiple feature domains.
+ *
+ * The loader creates client entries without configuration, so this plugin reads
+ * its own Host-served section through the settings transport rather than a
+ * second `apply` argument: `configForms.get(entryId)`. That keeps one source of
+ * truth for the switch and lets enable/disable take effect without a reload.
+ * The configuration page is registered on the outer scope so it survives the
+ * switch being turned off — otherwise the interface could never be turned back
+ * on from inside the app.
+ *
+ * @param ctx - client root context carrying the injected services.
+ */
+export declare function apply(ctx: Context): void;