@dumiflex/wp-kit 0.5.0 → 0.7.0

package/src/preview-readers.ts

@@ -0,0 +1,401 @@
+/**
+ * Defensive readers + parsers for published payloads. Pure (no Vue), shared
+ * by the per-type previews, the post header's feature pills and the bundle
+ * summary. A published payload is untrusted JSON, so every read tolerates a
+ * missing or mistyped field.
+ */
+import { tokenizeRich, type RichToken } from "./rich-tokenize";
+
+export type Obj = Record<string, unknown>;
+
+export function readString(obj: unknown, key: string): string | null {
+  if (!obj || typeof obj !== "object") return null;
+  const v = (obj as Obj)[key];
+  return typeof v === "string" ? v : null;
+}
+export function readNumber(obj: unknown, key: string): number | null {
+  if (!obj || typeof obj !== "object") return null;
+  const v = (obj as Obj)[key];
+  return typeof v === "number" ? v : null;
+}
+export function readArray(obj: unknown, key: string): unknown[] {
+  if (!obj || typeof obj !== "object") return [];
+  const v = (obj as Obj)[key];
+  return Array.isArray(v) ? v : [];
+}
+export function readObject(obj: unknown, key: string): Obj | null {
+  if (!obj || typeof obj !== "object") return null;
+  const v = (obj as Obj)[key];
+  if (!v || typeof v !== "object" || Array.isArray(v)) return null;
+  return v as Obj;
+}
+export function readStrings(obj: unknown, key: string): string[] {
+  return readArray(obj, key).filter((s): s is string => typeof s === "string");
+}
+/** Coerce a payload field into an axis map (`{axis: tag[]}`), keeping only
+ *  string members. Null when absent or empty. */
+export function readGroups(obj: unknown, key: string): Record<string, string[]> | null {
+  const raw = readObject(obj, key);
+  if (!raw) return null;
+  const out: Record<string, string[]> = {};
+  for (const [axis, members] of Object.entries(raw)) {
+    if (Array.isArray(members)) {
+      const tags = members.filter((m): m is string => typeof m === "string");
+      if (tags.length) out[axis] = tags;
+    }
+  }
+  return Object.keys(out).length ? out : null;
+}
+
+/** Engine rows nest type fields under `payload`; older flat seeds don't. */
+export function innerOf(payload: unknown): Obj | null {
+  return readObject(payload, "payload") ?? (payload && typeof payload === "object" ? (payload as Obj) : null);
+}
+
+/** Module type, or "bundle" for a bundle row (no `type`, has `children`). */
+export function payloadKind(payload: unknown): string | null {
+  return readString(payload, "type") ?? (readArray(payload, "children").length ? "bundle" : null);
+}
+
+// ─────────── grammar scanning ───────────
+
+/** Every token in `text`, brace/multi arms included (depth-first). */
+function allTokens(text: string): RichToken[] {
+  const out: RichToken[] = [];
+  const walk = (s: string): void => {
+    for (const t of tokenizeRich(s)) {
+      out.push(t);
+      for (const b of t.meta?.branches ?? []) walk(b);
+    }
+  };
+  walk(text);
+  return out;
+}
+export interface TextScan {
+  vars: string[];
+  negVars: string[];
+  refs: number;
+  picks: number;
+}
+export function scanText(text: string): TextScan {
+  const vars: string[] = [];
+  const negVars: string[] = [];
+  let refs = 0;
+  let picks = 0;
+  for (const t of allTokens(text)) {
+    if (t.kind === "var" && t.meta?.name) {
+      (t.meta.neg ? negVars : vars).push(t.meta.name);
+    } else if (t.kind === "ref") refs++;
+    else if (t.kind === "dp-brace" || t.kind === "dp-multi") picks++;
+  }
+  return { vars, negVars, refs, picks };
+}
+
+// ─────────── wildcard ───────────
+
+export interface WildcardOption {
+  value: string;
+  weight: number;
+  /** Plural tag list (a legacy singular `sub_category` folds in). */
+  tags: string[];
+  negative: string;
+  /** Schema v9: rolls normally, and is also used when nothing else is left to pick. */
+  fallback: boolean;
+}
+export interface WildcardAxis {
+  name: string;
+  tags: string[];
+}
+export function wildcardOptions(inner: unknown): WildcardOption[] {
+  return readArray(inner, "options")
+    .map((r) => {
+      const tags = readStrings(r, "sub_categories");
+      const singular = readString(r, "sub_category");
+      return {
+        value: readString(r, "value") ?? "",
+        weight: readNumber(r, "weight") ?? 1,
+        tags: tags.length ? tags : singular ? [singular] : [],
+        negative: readString(r, "negative") ?? "",
+        fallback: !!r && typeof r === "object" && (r as Obj).fallback === true,
+      };
+    })
+    .filter((o) => o.value);
+}
+/** Axes from `tag_groups`; without them, one flat axis over the
+ *  `sub_categories` registry (or none at all). */
+export function wildcardAxes(inner: unknown): WildcardAxis[] {
+  const groups = readGroups(inner, "tag_groups");
+  if (groups) return Object.entries(groups).map(([name, tags]) => ({ name, tags }));
+  const flat = readStrings(inner, "sub_categories");
+  return flat.length ? [{ name: "tag", tags: flat }] : [];
+}
+
+// ─────────── fixed values / combine ───────────
+
+export interface FixedValue {
+  name: string;
+  value: string;
+  negative: string;
+}
+export function fixedValues(inner: unknown): FixedValue[] {
+  // Engine shape is `values: [{id, name, value}]`; `entries/variable_name`
+  // was a stale community guess kept only for old published data.
+  const rows = readArray(inner, "values").length ? readArray(inner, "values") : readArray(inner, "entries");
+  return rows.map((r) => ({
+    name: readString(r, "name") ?? readString(r, "variable_name") ?? "",
+    value: readString(r, "value") ?? "",
+    negative: readString(r, "negative") ?? "",
+  }));
+}
+
+// ─────────── derivation ───────────
+
+export type ActionOp = "set" | "append" | "prepend" | "neg_add" | "neg_replace" | "other";
+export interface DerivationAction {
+  target: string;
+  op: ActionOp;
+  /** Raw mode string, shown when the op is unknown. */
+  mode: string;
+  value: string;
+}
+export interface CondTest {
+  kind: "test";
+  var: string;
+  op: string;
+  value: string | null;
+}
+export interface CondGroup {
+  kind: "group";
+  match: "all" | "any";
+  conditions: Condition[];
+}
+export type Condition = CondTest | CondGroup;
+export interface DerivationBranch {
+  condition: Condition | null;
+  actions: DerivationAction[];
+}
+export interface DerivationRule {
+  branches: DerivationBranch[];
+  fallback: DerivationAction[] | null;
+}
+/** Presence checks carry no value. */
+const VALUELESS_OPS = new Set(["exists", "not_exists", "is_empty", "is_not_empty"]);
+
+export function parseCondition(cond: unknown): Condition | null {
+  if (!cond || typeof cond !== "object") return null;
+  if ("conditions" in cond) {
+    const kids = readArray(cond, "conditions")
+      .map(parseCondition)
+      .filter((c): c is Condition => c !== null);
+    if (!kids.length) return null;
+    return { kind: "group", match: readString(cond, "match") === "any" ? "any" : "all", conditions: kids };
+  }
+  const op = readString(cond, "op") ?? "?";
+  const raw = (cond as Obj)["value"];
+  return {
+    kind: "test",
+    var: readString(cond, "var") ?? "?",
+    op,
+    value: VALUELESS_OPS.has(op) ? null : typeof raw === "string" ? raw : JSON.stringify(raw ?? ""),
+  };
+}
+function parseAction(action: unknown): DerivationAction {
+  const mode = readString(action, "mode") ?? "?";
+  const raw = (action as Obj | null)?.["value"];
+  const op: ActionOp =
+    mode === "replace"
+      ? "set"
+      : mode === "append"
+        ? "append"
+        : mode === "prepend"
+          ? "prepend"
+          : mode === "negative"
+            ? "neg_add"
+            : mode === "negative_replace"
+              ? "neg_replace"
+              : "other";
+  return {
+    target: readString(action, "target_var") ?? "?",
+    op,
+    mode,
+    value: typeof raw === "string" ? raw : JSON.stringify(raw ?? ""),
+  };
+}
+/** `action` then every `extra_actions` entry, in order (schema v8). Mirrors
+ *  the engine's `clause_actions`; never read `.action` alone. */
+export function clauseActions(clause: unknown): DerivationAction[] {
+  const out: DerivationAction[] = [];
+  const first = readObject(clause, "action");
+  if (first) out.push(parseAction(first));
+  for (const extra of readArray(clause, "extra_actions")) {
+    if (extra && typeof extra === "object") out.push(parseAction(extra));
+  }
+  return out;
+}
+export function derivationRules(inner: unknown): DerivationRule[] {
+  return readArray(inner, "rules").map((rule) => {
+    const elseClause = readObject(rule, "else");
+    return {
+      branches: readArray(rule, "branches").map((b) => ({
+        condition: parseCondition(readObject(b, "condition")),
+        actions: clauseActions(b),
+      })),
+      fallback: elseClause ? clauseActions(elseClause) : null,
+    };
+  });
+}
+export function conditionVars(c: Condition | null, out: string[] = []): string[] {
+  if (!c) return out;
+  if (c.kind === "test") out.push(c.var);
+  else for (const k of c.conditions) conditionVars(k, out);
+  return out;
+}
+export function hasGroups(c: Condition | null): boolean {
+  return c?.kind === "group";
+}
+
+// ─────────── variables in / out ───────────
+
+export interface VarFlow {
+  /** Variables this payload sets (value writes). */
+  sets: string[];
+  /** Variables it reads. */
+  reads: string[];
+  /** Variables whose negatives it touches. */
+  negatives: string[];
+}
+function uniq(xs: string[]): string[] {
+  return [...new Set(xs.filter(Boolean))];
+}
+/** What one module sets / reads. Bundles fold their children. */
+export function varFlow(payload: unknown): VarFlow {
+  const kind = payloadKind(payload);
+  if (kind === "bundle") {
+    const flows = readArray(payload, "children")
+      .filter((c) => (c as Obj | null)?.["enabled"] !== false)
+      .map(varFlow);
+    return {
+      sets: uniq(flows.flatMap((f) => f.sets)),
+      reads: uniq(flows.flatMap((f) => f.reads)),
+      negatives: uniq(flows.flatMap((f) => f.negatives)),
+    };
+  }
+  const inner = innerOf(payload);
+  const sets: string[] = [];
+  const reads: string[] = [];
+  const negatives: string[] = [];
+  const readText = (t: string): void => {
+    const s = scanText(t);
+    reads.push(...s.vars, ...s.negVars);
+  };
+  if (kind === "wildcard") {
+    const b = readString(inner, "var_binding");
+    if (b) sets.push(b);
+    for (const o of wildcardOptions(inner)) {
+      readText(o.value);
+      if (o.negative) {
+        readText(o.negative);
+        if (b) negatives.push(b);
+      }
+    }
+  } else if (kind === "fixed_values") {
+    for (const v of fixedValues(inner)) {
+      sets.push(v.name);
+      readText(v.value);
+      if (v.negative) negatives.push(v.name);
+    }
+  } else if (kind === "combine") {
+    const out = readString(inner, "output_var");
+    if (out) sets.push(out);
+    reads.push(...readStrings(inner, "input_vars"));
+    readText(readString(inner, "template") ?? "");
+    const neg = readString(inner, "negative") ?? "";
+    if (neg) {
+      readText(neg);
+      if (out) negatives.push(out);
+    }
+  } else if (kind === "derivation") {
+    for (const r of derivationRules(inner)) {
+      const clauses = [...r.branches.map((b) => b.actions), ...(r.fallback ? [r.fallback] : [])];
+      for (const b of r.branches) reads.push(...conditionVars(b.condition));
+      for (const a of clauses.flat()) {
+        readText(a.value);
+        if (a.op === "neg_add" || a.op === "neg_replace") negatives.push(a.target);
+        else sets.push(a.target);
+      }
+    }
+  }
+  return { sets: uniq(sets), reads: uniq(reads), negatives: uniq(negatives) };
+}
+
+// ─────────── feature pills ───────────
+
+/** Short labels for the notable features a payload uses, shown as pills in
+ *  the post header. Order is stable (most notable first). */
+export function payloadFeatures(payload: unknown): string[] {
+  const kind = payloadKind(payload);
+  const found = new Set<string>();
+  const addText = (t: string): void => {
+    const s = scanText(t);
+    if (s.refs) found.add("@refs");
+    if (s.picks) found.add("picks");
+    if (s.negVars.length) found.add("$var.neg");
+  };
+  const visit = (p: unknown): void => {
+    const k = payloadKind(p);
+    const inner = innerOf(p);
+    if (k === "wildcard") {
+      if (readGroups(inner, "tag_groups")) found.add("tag axes");
+      for (const o of wildcardOptions(inner)) {
+        addText(o.value);
+        if (o.weight !== 1) found.add("weights");
+        if (o.negative) {
+          found.add("negatives");
+          addText(o.negative);
+        }
+      }
+    } else if (k === "fixed_values") {
+      for (const v of fixedValues(inner)) {
+        addText(v.value);
+        if (v.negative) found.add("negatives");
+      }
+    } else if (k === "combine") {
+      addText(readString(inner, "template") ?? "");
+      const neg = readString(inner, "negative");
+      if (neg) {
+        found.add("negatives");
+        addText(neg);
+      }
+    } else if (k === "derivation") {
+      for (const r of derivationRules(inner)) {
+        const clauses = [...r.branches.map((b) => b.actions), ...(r.fallback ? [r.fallback] : [])];
+        if (r.branches.some((b) => hasGroups(b.condition))) found.add("AND / OR");
+        if (clauses.some((c) => c.length > 1)) found.add("multi-action");
+        for (const a of clauses.flat()) {
+          addText(a.value);
+          if (a.op === "neg_add" || a.op === "neg_replace") found.add("negatives");
+        }
+      }
+    } else if (k === "constraint") {
+      const matrix = readObject(inner, "matrix") ?? {};
+      const onlyUsed =
+        Object.values(matrix).some((row) =>
+          Object.values((row as Obj) ?? {}).some((c) => readString(c, "mode") === "only"),
+        ) || readArray(inner, "exceptions").some((e) => readString(e, "mode") === "only");
+      if (onlyUsed) found.add("only rule");
+      const sel = readObject(inner, "target_select");
+      const mode = readString(sel, "mode");
+      if (mode && mode !== "all") {
+        const count = readNumber(sel, "count");
+        found.add(`reach: ${mode}${count !== null ? ` ${count}` : ""}`);
+      }
+    } else if (k === "bundle") {
+      for (const c of readArray(p, "children")) visit(c);
+    }
+  };
+  visit(payload);
+  const order = ["tag axes", "weights", "negatives", "$var.neg", "AND / OR", "multi-action", "only rule", "@refs", "picks"];
+  const sorted = order.filter((f) => found.has(f));
+  for (const f of found) if (!order.includes(f)) sorted.push(f);
+  return kind ? sorted : [];
+}

package/src/preview.css

@@ -0,0 +1,194 @@
+/* Shared chrome for the per-type payload previews (stats strip, toolbar,
+   row tables, section labels). Each preview pulls it in scoped
+   (`<style scoped src="./preview.css">`), so it styles only that piece's own
+   markup. Every selector is `.wp-pv-*`. */
+
+.wp-pv {
+  container-type: inline-size;
+  min-width: 0;
+}
+
+/* ── stats strip ─────────────────────────────────────────────── */
+.wp-pv-stats {
+  display: flex;
+  flex-wrap: wrap;
+  border-bottom: 1px solid var(--wp-border);
+}
+.wp-pv-stat {
+  padding: 12px 18px;
+  border-right: 1px solid var(--wp-border);
+  min-width: 0;
+}
+.wp-pv-stat b {
+  display: block;
+  font-size: 17px;
+  font-weight: 600;
+  color: var(--wp-text);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+.wp-pv-stat span {
+  font-size: 11.5px;
+  color: var(--wp-text-muted);
+  white-space: nowrap;
+}
+
+/* ── toolbar ─────────────────────────────────────────────────── */
+.wp-pv-tool {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px 10px;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--wp-border);
+}
+.wp-pv-search {
+  width: 220px;
+  max-width: 100%;
+}
+.wp-pv-label {
+  font-size: 10.5px;
+  color: var(--wp-text-dim);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+.wp-pv-tool__end {
+  margin-left: auto;
+}
+.wp-pv-count {
+  font-size: 12px;
+  color: var(--wp-text-muted);
+  font-variant-numeric: tabular-nums;
+}
+
+/* ── row tables ──────────────────────────────────────────────── */
+.wp-pv-table {
+  width: 100%;
+  border-collapse: collapse;
+  table-layout: fixed;
+}
+.wp-pv-table th,
+.wp-pv-table td {
+  padding: 7px 12px;
+  border-bottom: 1px solid var(--wp-border);
+  text-align: left;
+  vertical-align: top;
+}
+.wp-pv-table th {
+  font-size: 10.5px;
+  font-weight: 500;
+  color: var(--wp-text-dim);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  padding-top: 8px;
+  padding-bottom: 6px;
+}
+.wp-pv-table td {
+  font-size: 13px;
+  color: var(--wp-text);
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+.wp-pv-col-n {
+  width: 40px;
+}
+.wp-pv-table .wp-pv-n {
+  width: 40px;
+  text-align: right;
+  color: var(--wp-text-dim);
+  font-family: var(--wp-font-mono);
+  font-size: 11px;
+}
+.wp-pv-table .wp-pv-var {
+  font-family: var(--wp-font-mono);
+  font-size: 12px;
+  color: var(--wp-success);
+}
+.wp-pv-neg-cell {
+  color: var(--wp-danger-text, var(--wp-danger));
+  font-size: 12px;
+}
+.wp-pv-clamp {
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+.wp-pv-more {
+  padding: 4px 12px;
+  border-bottom: 1px solid var(--wp-border);
+}
+.wp-pv-empty {
+  margin: 0;
+  padding: 18px 16px;
+  color: var(--wp-text-muted);
+  font-size: 13px;
+}
+
+/* Wildcard fallback option (schema v9): rolls normally, also stands in. */
+.wp-pv-fbtag {
+  font-family: var(--wp-font-mono);
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  padding: 1px 6px;
+  border-radius: min(3px, var(--wp-radius-cap, 999px));
+  background: color-mix(in oklab, var(--wp-accent-500) 18%, transparent);
+  color: var(--wp-accent-text);
+  white-space: nowrap;
+}
+/* NEG tag, shared by every negative cell / block. */
+.wp-pv-negtag {
+  font-family: var(--wp-font-mono);
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  padding: 0 4px;
+  margin-right: 5px;
+  border-radius: min(3px, var(--wp-radius-cap, 999px));
+  background: color-mix(in oklab, var(--wp-danger) 18%, transparent);
+  color: var(--wp-danger-text, var(--wp-danger));
+}
+
+/* ── section label + text block ──────────────────────────────── */
+.wp-pv-sec {
+  padding: 14px 16px 6px;
+  font-size: 10.5px;
+  color: var(--wp-text-dim);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+.wp-pv-block {
+  margin: 0 16px 4px;
+  padding: 12px 14px;
+  background: var(--wp-bg-2);
+  border: 1px solid var(--wp-border);
+  border-radius: min(10px, var(--wp-radius-cap, 999px));
+  font-family: var(--wp-font-mono);
+  font-size: 13px;
+  line-height: 1.9;
+  color: var(--wp-text);
+  overflow-wrap: anywhere;
+}
+.wp-pv-block--neg {
+  border-color: color-mix(in oklab, var(--wp-danger) 28%, transparent);
+}
+
+/* Narrow hosts (embed, phones): drop secondary columns. */
+@container (max-width: 640px) {
+  .wp-pv-hide-narrow {
+    display: none;
+  }
+  .wp-pv-stat {
+    padding: 10px 12px;
+  }
+  .wp-pv-table td,
+  .wp-pv-table th {
+    padding-left: 8px;
+    padding-right: 8px;
+  }
+  .wp-pv-col-n,
+  .wp-pv-table .wp-pv-n {
+    width: 28px;
+  }
+}

package/src/slider-math.ts

@@ -1,5 +1,5 @@
 /**
- * Number helpers for sliders (Slider now, the two-thumb range later): clamp
+ * Number helpers for Slider (one thumb or a pair): clamp
  * to the ends, snap to the step counted from `min`, and turn a pointer
  * position into a value. Steps like 0.1 snap without float fuzz.
  */
@@ -43,3 +43,47 @@ export function keyStep(key: string, v: number, min: number, max: number, step:
     default: return null;
   }
 }
+
+/**
+ * Mark snapping. `snap: true` keeps the value on a mark (the nearest one);
+ * a number pulls it onto a mark only within that distance, so the thumb
+ * moves freely by its step elsewhere and "clicks" into a mark near one.
+ * With no marks, or snap off, the value comes back as it was.
+ */
+export function snapToMarks(v: number, marks: readonly number[], snapTo: boolean | number | undefined): number {
+  if (!snapTo || !marks.length) return v;
+  let best = marks[0] ?? v;
+  for (const m of marks) if (Math.abs(m - v) < Math.abs(best - v)) best = m;
+  if (snapTo === true) return best;
+  return Math.abs(best - v) <= snapTo ? best : v;
+}
+
+/**
+ * A key press on a slider that only takes marks (`snap: true`): arrows go to
+ * the next mark up or down, PageUp/PageDown jump `big` marks, Home/End the
+ * first and last. Null for a key the slider ignores.
+ */
+export function keyToMark(key: string, v: number, marks: readonly number[], big = 3): number | null {
+  const sorted = [...new Set(marks)].sort((a, b) => a - b);
+  if (!sorted.length) return null;
+  // Where v sits: the index of the mark at it, or between two marks.
+  const at = sorted.findIndex((m) => m >= v);
+  const exact = at >= 0 && sorted[at] === v;
+  const up = (n: number): number => {
+    const from = at < 0 ? sorted.length : exact ? at : at - 1;
+    return sorted[Math.min(sorted.length - 1, from + n)] ?? v;
+  };
+  const down = (n: number): number => {
+    const from = at < 0 ? sorted.length : at;
+    return sorted[Math.max(0, from - n)] ?? v;
+  };
+  switch (key) {
+    case "ArrowRight": case "ArrowUp": return up(1);
+    case "ArrowLeft": case "ArrowDown": return down(1);
+    case "PageUp": return up(big);
+    case "PageDown": return down(big);
+    case "Home": return sorted[0] ?? v;
+    case "End": return sorted[sorted.length - 1] ?? v;
+    default: return null;
+  }
+}

package/src/theme/looks.css

@@ -47,8 +47,10 @@
 /* --wp-radius-cap: the roundest a corner may get in this look. Fixed radii
    in components are written min(Npx, var(--wp-radius-cap, 999px)) and
    pills var(--wp-radius-cap, 999px), so Orbit draws them as authored and a
-   square look squares them without a rule per component. Circles (50%)
-   stay circles. The theme audit (scripts/theme-audit) fails on a corner
+   square look squares them without a rule per component. Circles are
+   min(50%, var(--wp-radius-cap, 999px)): round in Orbit, softened in Crisp,
+   square in Terminal and TUI (dots, radios, avatars, the timeline).
+   src/__tests__/corners.test.ts fails on a raw radius. The theme audit (scripts/theme-audit) fails on a corner
    rounder than the cap. */
 html[data-wp-look="crisp"] { --wp-radius-cap: 4px; }
 html[data-wp-look="terminal"],
@@ -362,10 +364,8 @@ html[data-wp-look="tui"] .wp-check:is([aria-checked="true"], [data-checked="true
 html[data-wp-look="tui"] .wp-check:is([aria-checked="mixed"], [data-indeterminate="true"]):not([data-checked="true"])::before { content: "[-]"; color: var(--wp-accent-text); }
 html[data-wp-look="tui"] .wp-page__title { font-size: 16px; font-weight: 700; letter-spacing: 0; }
 /* Radios read ( ) / (*) beside the [ ] / [x] checkboxes; the drawn dot
-   hides. RadioGroup marks the picked option on the row (data-checked), the
-   plain .wp-radio is a real input (:checked). */
-html[data-wp-look="tui"] .wp-radio-group__opt .wp-radio-group__dot,
-html[data-wp-look="tui"] .wp-radio {
+   hides. RadioGroup marks the picked option on the row (data-checked). */
+html[data-wp-look="tui"] .wp-radio-group__opt .wp-radio-group__dot {
   width: auto;
   min-width: 3ch;
   height: auto;
@@ -381,19 +381,6 @@ html[data-wp-look="tui"] .wp-radio-group__opt[data-checked] .wp-radio-group__dot
 html[data-wp-look="tui"] .wp-radio-group__dot::before { content: "( )"; }
 html[data-wp-look="tui"] .wp-radio-group__opt[data-checked] .wp-radio-group__dot::before { content: "(*)"; color: var(--wp-accent-text); }
 html[data-wp-look="tui"] .wp-radio-group__opt[aria-disabled="true"][data-checked] .wp-radio-group__dot::before { color: var(--wp-text-dim); }
-html[data-wp-look="tui"] .wp-radio::before,
-html[data-wp-look="tui"] .wp-radio:disabled::before {
-  content: "( )";
-  width: auto;
-  height: auto;
-  border-radius: 0;
-  background: transparent;
-  transform: none;
-}
-html[data-wp-look="tui"] .wp-radio:checked::before { content: "(*)"; color: var(--wp-accent-text); }
-html[data-wp-look="tui"] .wp-radio:disabled:checked::before { content: "(*)"; color: var(--wp-text-dim); }
-html[data-wp-look="tui"] .wp-radio:checked,
-html[data-wp-look="tui"] .wp-radio:disabled:checked { background: transparent; }
 
 /* ================= Canvas previews ignore the look =================
    The canvas keeps ComfyUI's ground in every look (only the accent follows