@weasel-js/prefs 1.10.1 → 1.11.0

package/dist/index.d.ts

@@ -1,7 +1,11 @@
-import { P as PrefLeaf, a as PrefGroup, b as PrefSection, c as PrefNumber, d as PrefList, e as PrefMap, f as PrefCondition, g as PrefConditionReader, h as PrefBoolean, i as PrefString, j as PrefColor, k as PrefEnumBase, l as PrefSelection, m as PrefLocus, n as PrefAlias, o as PrefObject, p as PrefKind } from './open-C83pU7Va.js';
-export { B as BuiltinPref, q as PREF_BLENDS, r as PREF_KINDS, s as PrefAction, t as PrefActionContext, u as PrefActionControl, v as PrefAtPath, w as PrefBarOverflow, x as PrefBase, y as PrefBlend, z as PrefBooleanControl, A as PrefBooleanEncoding, C as PrefChange, D as PrefConditionValue, E as PrefCustom, F as PrefEnum, G as PrefEnumControl, H as PrefEnumEncoding, I as PrefField, J as PrefFunctionUnit, K as PrefGroupAs, L as PrefLabel, M as PrefLinearUnit, N as PrefNumberControl, O as PrefNumberUnit, Q as PrefPaint, R as PrefPair, S as PrefPath, T as PrefSectionAs, U as PrefSeparator, V as PrefStringControl, W as PrefTest, X as PrefUnion, Y as PrefValidator, Z as PrefValueAt, _ as PrefValueOf, $ as PrefWeighted, a0 as PrefWeights, a1 as PrefsMigration, a2 as PrefsOptions, a3 as PrefsStore, a4 as ResolvedPrefUnit, a5 as isBuiltinPref, a6 as isPrefCondition, a7 as isPrefLinearUnit, a8 as isPrefLocus, a9 as mapPrefConditionPaths, aa as openPrefs, ab as openPrefsSync, ac as pairRowsOf, ad as prefAliasName, ae as prefAliasTarget, af as prefAliasedLeaf, ag as prefConditionHolds, ah as prefConditionPaths, ai as prefConditionReadsItem, aj as prefGroupIsPage, ak as prefIsEnabled, al as prefIsShown, am as prefLocusMember, an as prefLocusSelectors, ao as prefUnit, ap as prefVariantDefault, aq as prefVariantOf, ar as repairPrefValue, as as resolvePrefUnit } from './open-C83pU7Va.js';
+import { Endless } from '@weasel-js/quantity';
+import { P as PrefLeaf, a as PrefGroup, b as PrefSection, c as PrefNumber, d as PrefList, e as PrefMap, f as PrefCondition, g as PrefConditionReader, h as PrefBoolean, i as PrefString, j as PrefColor, k as PrefEnumBase, l as PrefAction, m as PrefActions, n as PrefLabel, o as PrefSeparator, p as PrefAlias, q as PrefObject, r as PrefKind } from './groups-BDZC-ywb.js';
+export { B as BuiltinPref, s as PREF_KINDS, t as PrefActionContext, u as PrefActionControl, v as PrefBarLead, w as PrefBarOverflow, x as PrefBase, y as PrefBooleanControl, z as PrefBooleanEncoding, A as PrefBoundAt, C as PrefBoundReader, D as PrefConditionValue, E as PrefCustom, F as PrefEnum, G as PrefEnumControl, H as PrefEnumEncoding, I as PrefField, J as PrefFunctionUnit, K as PrefGroupAs, L as PrefLinearUnit, M as PrefLocus, N as PrefNumberBase, O as PrefNumberControl, Q as PrefNumberUnit, R as PrefPaint, S as PrefPair, T as PrefSectionAs, U as PrefSelection, V as PrefStringControl, W as PrefTest, X as PrefUnion, Y as PrefValueBase, Z as PrefWeighted, _ as PrefWeights, $ as ResolvedPrefUnit, a0 as isBuiltinPref, a1 as isPrefCondition, a2 as isPrefLinearUnit, a3 as isPrefLocus, a4 as mapPrefConditionPaths, a5 as pairRowsOf, a6 as prefAliasName, a7 as prefAliasTarget, a8 as prefAliasedLeaf, a9 as prefAsBox, aa as prefClampNumber, ab as prefConditionHolds, ac as prefConditionPaths, ad as prefConditionReadsItem, ae as prefGroupIsPage, af as prefIsEnabled, ag as prefIsShown, ah as prefLocusMember, ai as prefLocusSelectors, aj as prefNumberAt, ak as prefUnit, al as prefUnitAccepts, am as prefVariantDefault, an as prefVariantOf, ao as resolvePrefUnit } from './groups-BDZC-ywb.js';
+export { P as PREF_BLENDS, a as PrefAtPath, b as PrefBlend, c as PrefChange, d as PrefPath, e as PrefValidator, f as PrefValueAt, g as PrefValueOf, h as PrefsMigration, i as PrefsOptions, j as PrefsStore, o as openPrefs, k as openPrefsSync, r as repairPrefValue } from './open-VJ1zlFJz.js';
+import { P as PrefsCssSource, a as PrefsCssOptions } from './css-v-LpmTll.js';
+export { p as prefsCss, b as prefsCssAttributes } from './css-v-LpmTll.js';
+import '@weasel-js/icons';
 import '@weasel-js/storage';
-import '@weasel-js/quantity';
 
 /**
  * A number leaf's bounds in the unit it is displayed in.
@@ -12,16 +16,17 @@ import '@weasel-js/quantity';
  * `max` are points, so they convert the way the value does; `step` is a
  * distance, and a unit with an offset maps zero somewhere else, so converting
  * it as a point would scale it wrong. A decreasing conversion swaps which end
- * is the lower one.
+ * is the lower one, and which end is `endless`.
  */
 declare function prefDisplayBounds(p: PrefNumber): {
     min?: number;
     max?: number;
     step: number;
+    endless?: Endless;
 };
 /** Distinguishes a leaf from a group or a section while walking a schema tree. */
 declare function isPrefLeaf(node: PrefLeaf | PrefGroup | PrefSection): node is PrefLeaf;
-/** Whether a leaf has a value to store: an `action` is a button and holds none, an `alias` shows another leaf's,
+/** Whether a leaf has a value to store: an `action` is a button and holds none, nor does an `actions` run of them, an `alias` shows another leaf's,
  *  and a `label` and a `separator` are text and a rule. */
 declare function prefHoldsValue(leaf: PrefLeaf): boolean;
 /** Distinguishes a section, whose key adds nothing to a path, from a group, whose key is a segment. */
@@ -59,7 +64,7 @@ declare function prefLeaves(schema: PrefGroup): Map<string, PrefLeaf>;
 declare function flattenPrefValues(schema: PrefGroup, tree: unknown): [string, unknown][];
 /**
  * Drop every leaf that does not answer to `query`, pruning groups left empty.
- * A group whose own name matches keeps all of its leaves. An empty or
+ * A group whose own name or tag matches keeps all of its leaves. An empty or
  * whitespace query matches everything.
  *
  * An alias answers as the row it draws: its target's name and description
@@ -82,13 +87,22 @@ type PrefTabRun<T> = {
  */
 declare function prefTabRuns<T>(items: readonly T[], isTab: (item: T) => boolean): PrefTabRun<T>[];
 
+/** The leaves carrying `tag`, themselves or through a group above them, by
+ *  path, in schema order. */
+declare function prefLeavesTagged(schema: PrefGroup | PrefSection, tag: string): Map<string, PrefLeaf>;
+/** The tags the leaf at `path` carries: each group's above it, outermost
+ *  first, then its own. Empty for a path that names no leaf. */
+declare function prefLeafTags(schema: PrefGroup | PrefSection, path: string): readonly string[];
+
 /** One thing wrong with a condition: it is not one, it reads a path no leaf
- *  holds a value at, it compares a leaf against a value it never holds, it
+ *  holds a value at, it compares a leaf against a value it never holds — an
+ *  enum against a string none of its options is being `option`, which a
+ *  surface may take as a test that never matches — it
  *  never holds whatever the leaf does, as an `in` of no values, it is the
  *  `showIf` of a list's or a map's item, which is drawn with each entry, or
  *  it reads from the entry on a node that no list or map draws. */
 interface PrefConditionProblem {
-    code: 'malformed' | 'no-leaf' | 'no-value' | 'value' | 'never' | 'item-show' | 'no-item';
+    code: 'malformed' | 'no-leaf' | 'no-value' | 'value' | 'option' | 'never' | 'item-show' | 'no-item';
     /** The path read, where the problem is with one. */
     path?: string;
     problem: string;
@@ -292,8 +306,6 @@ declare function checkPrefSplits(schema: PrefGroup): PrefSplitProblem[];
 
 /** What a builder takes after the leaf's name and default: any of the leaf's other fields. */
 type Rest<L> = Partial<Omit<L, 'kind' | 'name' | 'default'>>;
-/** One option of an enum, or its value alone, which is labeled with the value's first letter raised. */
-type OptionOf<T extends string> = T | PrefEnumBase<T>['options'][number];
 /**
  * Builders for a preferences schema, each returning what the literal would
  * hold. `pref.group('View', { grid: pref.boolean('Grid', true) })` is
@@ -309,61 +321,39 @@ declare const pref: {
     section<const M extends Record<string, PrefLeaf | PrefSection>>(name: string, members: M, options?: Omit<PrefSection, "name" | "members">): Omit<PrefSection, "members"> & {
         members: M;
     };
-    number: (name: string, def: number, rest?: Rest<PrefNumber>) => PrefNumber;
+    number: (name: string, def: number, rest?: Rest<PrefNumber>) => PrefNumber & {
+        default: number;
+    };
     boolean: (name: string, def: boolean, rest?: Rest<PrefBoolean>) => PrefBoolean;
     string: (name: string, def: string, rest?: Rest<PrefString>) => PrefString;
     color: (name: string, def: string, rest?: Rest<PrefColor>) => PrefColor;
     /** A fixed set of choices. An option given as its value alone is labeled with that value, its first letter raised. */
-    enum<const T extends string>(name: string, def: NoInfer<T>, options: readonly OptionOf<T>[], rest?: Omit<Rest<PrefEnumBase<T>>, "options">): PrefEnumBase<T> & {
+    enum<const T extends string>(name: string, def: NoInfer<T>, options: readonly (T | PrefEnumBase<T>["options"][number])[], rest?: Omit<Rest<PrefEnumBase<T>>, "options">): PrefEnumBase<T> & {
         default: T;
         clearable?: false;
     };
+    /** A button firing the registered action `action` (`id` or `id:variant`). Its name defaults to empty, which shows the action's own label. */
+    action: (action: string, rest?: Partial<Omit<PrefAction, "kind" | "default" | "action">>) => PrefAction;
+    /** Every action registered in the action group `group`. */
+    actions: (group: string, rest?: Partial<Omit<PrefActions, "kind" | "default" | "group">>) => PrefActions;
+    label: (name: string, rest?: Rest<PrefLabel>) => PrefLabel;
+    separator: () => PrefSeparator;
 };
 
-/** How {@link prefsCss} names and writes things. */
-interface PrefsCssOptions {
-    /** The selector of the element the properties are set on, and the selectors' attributes read from. Default `:root`. */
-    root?: string;
-    /** The custom property a leaf is written as, or `null` to leave the leaf out. Default: `--`, then the path with
-     *  each `.` and each capital turned into a `-` (`look.gridGap` is `--look-grid-gap`). */
-    property?: (path: string, leaf: PrefLeaf) => string | null;
-    /** The attribute a selector's option is read from. Default: `data-`, then the path as a property spells it. */
-    attribute?: (selector: string) => string;
-    /** The CSS text of a value, `null` to leave it out, or `undefined` for what its kind writes by itself. */
-    value?: (value: unknown, leaf: PrefLeaf, path: string) => string | null | undefined;
-}
-/** What {@link prefsCss} reads of a store: any `PrefsStore` is one. */
-interface PrefsCssSource {
-    schema: PrefGroup;
-    values(read?: {
-        at?: PrefSelection;
-    }): Record<string, unknown>;
-    locus(path: string): PrefLocus | undefined;
-    get(path: string): unknown;
-}
 /**
- * The store's values as CSS custom properties.
- *
- * The first block sets every leaf on `root`, a split one at the member the
- * selectors' defaults name, so a page that sets no attribute still has a
- * value for each. A block follows for each choice of options some value tells
- * apart, matched by an attribute per selector on that same element; a selector
- * is written under each of its own options too. Every block is inside
- * `:where()`, so none outranks another by how many attributes it names, and a
- * rule of the page's own wins. Blocks naming more selectors come later.
- *
- * A number is written in its display unit where the unit's suffix is a CSS
- * unit, and bare otherwise; a boolean as `1` or `0`; a color as it is held; an
- * enum's option as an identifier; a string quoted. A leaf of any other kind is
- * left out unless `value` writes it.
+ * A schema's defaults read the way a store at defaults reads them, a split
+ * default by its `defaultLocus` — what `prefsCss` needs to write a schema's
+ * stylesheet with no store and no storage, at build time say.
  */
-declare function prefsCss(store: PrefsCssSource, options?: PrefsCssOptions): string;
+declare function prefsDefaultsSource(schema: PrefGroup): PrefsCssSource;
+
 /**
- * The attribute for each selector and the option it is set to: what to set
- * on the `root` element for the blocks of {@link prefsCss} to match the
- * store's own choice.
+ * `prefsCss` names for the kit's own settings: `tree.typeaheadMs` writes as
+ * `--wzl-kit-tree-typeahead-ms`, clear of theme tokens. With `at`, only the
+ * leaves under it are written, each named from below it; a selector outside
+ * `at` keeps its whole path in its attribute name.
  */
-declare function prefsCssAttributes(store: Pick<PrefsCssSource, 'schema' | 'get'>, options?: Pick<PrefsCssOptions, 'attribute'>): Record<string, string>;
+declare function kitSettingsCssOptions(at?: string): PrefsCssOptions;
 
 /**
  * The schema that answers for the value at `path`: `schema` where a leaf of
@@ -483,4 +473,12 @@ declare function prefDrawsSeveral(leaf: {
     kind: string;
 }): boolean;
 
-export { PREF_ENTRY, PREF_KIND_TRAITS, PREF_SCOPE, type PairRun, PrefAlias, type PrefAliasTargets, type PrefAliasTargetsOptions, PrefBoolean, PrefColor, PrefCondition, type PrefConditionField, type PrefConditionJudge, type PrefConditionProblem, PrefConditionReader, type PrefConditionSite, type PrefConditionsApplied, type PrefConditionsOptions, type PrefEntry, type PrefEntryApplied, PrefEnumBase, PrefGroup, PrefKind, type PrefKindTraits, PrefLeaf, PrefList, PrefLocus, PrefMap, PrefNumber, PrefObject, type PrefSchemaConditionProblem, type PrefScope, type PrefScopeAtOptions, PrefSection, PrefSelection, type PrefSplitProblem, PrefString, type PrefTabRun, type PrefsCssOptions, type PrefsCssSource, VERSION_RECORD, applyPrefConditions, applyPrefEntryConditions, checkPrefCondition, checkPrefConditions, checkPrefSplits, filterPrefSubtree, flattenPrefValues, isPrefLeaf, isPrefSection, pairRuns, pref, prefAliasTargets, prefDisplayBounds, prefDrawsSeveral, prefFitsHeading, prefHeadingKey, prefHoldsValue, prefIsCompound, prefJudge, prefLeafAt, prefLeaves, prefObjectBase, prefObjectWithField, prefReader, prefSchemaHolding, prefScopeAt, prefScopeUnder, prefSectionLeaves, prefShownReader, prefShownValue, prefTabRuns, prefType, prefValueAtPath, prefsCss, prefsCssAttributes, visiblePrefSubtree };
+/**
+ * One group named `name` holding every child of `groups`. Groups at the same
+ * key merge, the first one's own fields kept; a leaf meeting anything at the
+ * same key throws. Composes schemas that each add to the same areas, such as
+ * the kit settings groups that `ui` and `core` both give a `targets` group.
+ */
+declare function mergePrefGroups(name: string, ...groups: readonly PrefGroup[]): PrefGroup;
+
+export { PREF_ENTRY, PREF_KIND_TRAITS, PREF_SCOPE, type PairRun, PrefAction, PrefActions, PrefAlias, type PrefAliasTargets, type PrefAliasTargetsOptions, PrefBoolean, PrefColor, PrefCondition, type PrefConditionField, type PrefConditionJudge, type PrefConditionProblem, PrefConditionReader, type PrefConditionSite, type PrefConditionsApplied, type PrefConditionsOptions, type PrefEntry, type PrefEntryApplied, PrefEnumBase, PrefGroup, PrefKind, type PrefKindTraits, PrefLabel, PrefLeaf, PrefList, PrefMap, PrefNumber, PrefObject, type PrefSchemaConditionProblem, type PrefScope, type PrefScopeAtOptions, PrefSection, PrefSeparator, type PrefSplitProblem, PrefString, type PrefTabRun, PrefsCssOptions, PrefsCssSource, VERSION_RECORD, applyPrefConditions, applyPrefEntryConditions, checkPrefCondition, checkPrefConditions, checkPrefSplits, filterPrefSubtree, flattenPrefValues, isPrefLeaf, isPrefSection, kitSettingsCssOptions, mergePrefGroups, pairRuns, pref, prefAliasTargets, prefDisplayBounds, prefDrawsSeveral, prefFitsHeading, prefHeadingKey, prefHoldsValue, prefIsCompound, prefJudge, prefLeafAt, prefLeafTags, prefLeaves, prefLeavesTagged, prefObjectBase, prefObjectWithField, prefReader, prefSchemaHolding, prefScopeAt, prefScopeUnder, prefSectionLeaves, prefShownReader, prefShownValue, prefTabRuns, prefType, prefValueAtPath, prefsDefaultsSource, visiblePrefSubtree };

package/dist/index.js

@@ -1,5 +1,9 @@
-import { prefLeafHoldingIn, prefLeafHolding, prefSchemaHolding, UNSEEN, prefConditionHolds, prefValueAtPath, isPrefSection, prefSectionLeaves, isPrefLeaf, prefLeafAt, prefLeaves, prefHoldsValue, prefSelectors, prefAliasTarget, prefAliasedLeaf, isBuiltinPref, pairRowsOf, prefConditionReadsItem, visiblePrefSubtree, resolvePrefUnit, isPrefLocus } from './chunk-ASSX3JHY.js';
-export { PREF_BLENDS, PREF_KINDS, VERSION_RECORD, checkPrefCondition, checkPrefConditions, checkPrefSplits, filterPrefSubtree, flattenPrefValues, isBuiltinPref, isPrefCondition, isPrefLeaf, isPrefLinearUnit, isPrefLocus, isPrefSection, mapPrefConditionPaths, openPrefs, openPrefsSync, pairRowsOf, prefAliasName, prefAliasTarget, prefAliasedLeaf, prefConditionHolds, prefConditionPaths, prefConditionReadsItem, prefDisplayBounds, prefHoldsValue, prefIsEnabled, prefIsShown, prefLeafAt, prefLeaves, memberAt as prefLocusMember, locusSelectors as prefLocusSelectors, prefSchemaHolding, prefSectionLeaves, prefUnit, prefValueAtPath, prefVariantDefault, prefVariantOf, repairPrefValue, resolvePrefUnit, visiblePrefSubtree } from './chunk-ASSX3JHY.js';
+import { prefLeafHoldingIn, prefLeafHolding, prefSchemaHolding, UNSEEN, prefConditionHolds, isBuiltinPref, pairRowsOf, prefConditionReadsItem } from './chunk-WN6QQICK.js';
+export { PREF_KINDS, checkPrefCondition, checkPrefConditions, isBuiltinPref, isPrefCondition, kitSettingsCssOptions, mapPrefConditionPaths, openPrefs, openPrefsSync, pairRowsOf, prefConditionHolds, prefConditionPaths, prefConditionReadsItem, prefIsEnabled, prefIsShown, prefSchemaHolding } from './chunk-WN6QQICK.js';
+export { prefsDefaultsSource } from './chunk-ZLXZRX73.js';
+import { prefValueAtPath, isPrefSection, prefSectionLeaves, isPrefLeaf, prefLeafAt, prefAliasTarget, prefAliasedLeaf, visiblePrefSubtree } from './chunk-OZFER7VN.js';
+export { PREF_BLENDS, VERSION_RECORD, checkPrefSplits, filterPrefSubtree, flattenPrefValues, isPrefLeaf, isPrefLinearUnit, isPrefLocus, isPrefSection, prefAliasName, prefAliasTarget, prefAliasedLeaf, prefClampNumber, prefDisplayBounds, prefHoldsValue, prefLeafAt, prefLeaves, memberAt as prefLocusMember, locusSelectors as prefLocusSelectors, prefNumberAt, prefSectionLeaves, prefUnit, prefUnitAccepts, prefValueAtPath, prefVariantDefault, prefVariantOf, prefsCss, prefsCssAttributes, repairPrefValue, resolvePrefUnit, visiblePrefSubtree } from './chunk-OZFER7VN.js';
+import { hasTag } from '@weasel-js/registry';
 
 // src/tabRuns.ts
 function prefTabRuns(items, isTab) {
@@ -17,6 +21,26 @@ function prefTabRuns(items, isTab) {
   }
   return out;
 }
+function taggedLeaves(schema) {
+  const out = [];
+  const walk = (node, prefix, above) => {
+    const section = isPrefSection(node);
+    for (const [key, child] of Object.entries(section ? node.members : node.children)) {
+      const path = section || prefix === "" ? key : `${prefix}.${key}`;
+      const tags = child.tags ? [...above, ...child.tags] : above;
+      if (isPrefLeaf(child)) out.push([path, child, tags]);
+      else walk(child, section ? prefix : path, tags);
+    }
+  };
+  walk(schema, "", schema.tags ?? []);
+  return out;
+}
+function prefLeavesTagged(schema, tag) {
+  return new Map(taggedLeaves(schema).filter(([, , tags]) => hasTag(tags, tag)).map(([path, leaf2]) => [path, leaf2]));
+}
+function prefLeafTags(schema, path) {
+  return taggedLeaves(schema).find(([p]) => p === path)?.[2] ?? [];
+}
 
 // src/shown.ts
 function prefShownValue(leaf2, stored, siblings) {
@@ -243,108 +267,15 @@ var pref = {
   enum(name, def, options, rest) {
     const full = options.map((option) => typeof option === "string" ? { value: option, label: labeled(option) } : option);
     return { kind: "enum", name, description: "", default: def, ...rest, options: full };
-  }
+  },
+  /** A button firing the registered action `action` (`id` or `id:variant`). Its name defaults to empty, which shows the action's own label. */
+  action: (action, rest) => leaf("action", "", void 0, { action, ...rest }),
+  /** Every action registered in the action group `group`. */
+  actions: (group, rest) => leaf("actions", "", void 0, { group, ...rest }),
+  label: (name, rest) => leaf("label", name, void 0, rest),
+  separator: () => leaf("separator", "", void 0, void 0)
 };
 
-// src/css.ts
-var kebab = (path) => path.replace(/\./g, "-").replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-var CSS_UNITS = {
-  px: "px",
-  "%": "%",
-  em: "em",
-  rem: "rem",
-  ch: "ch",
-  pt: "pt",
-  vw: "vw",
-  vh: "vh",
-  ms: "ms",
-  s: "s",
-  "\xB0": "deg",
-  deg: "deg",
-  rad: "rad",
-  turn: "turn"
-};
-var IDENT = /^-?[A-Za-z_][\w-]*$/;
-var quoted = (text) => `'${text.replace(/[\\']/g, "\\$&")}'`;
-function cssValue(leaf2, value) {
-  switch (leaf2.kind) {
-    case "number": {
-      if (typeof value !== "number" || !Number.isFinite(value)) return null;
-      const { unit } = leaf2;
-      const resolved = unit ? resolvePrefUnit(unit) : void 0;
-      const shown = resolved ? resolved.toDisplay(value) : value;
-      const suffix = resolved?.suffix !== void 0 && Object.hasOwn(CSS_UNITS, resolved.suffix) ? CSS_UNITS[resolved.suffix] : "";
-      return `${Number(shown.toFixed(6))}${suffix}`;
-    }
-    case "boolean":
-      return typeof value === "boolean" ? value ? "1" : "0" : null;
-    case "color":
-      return typeof value === "string" && value !== "" ? value : null;
-    case "enum":
-      if (typeof value !== "string" || leaf2.encoding) return null;
-      return IDENT.test(value) ? value : quoted(value);
-    case "string":
-      return typeof value === "string" ? quoted(value) : null;
-    default:
-      return null;
-  }
-}
-function toldApart(held, optionsOf, absent) {
-  const out = [];
-  const walk = (value, under2) => {
-    if (!isPrefLocus(value)) {
-      out.push({ under: under2, value });
-      return;
-    }
-    for (const option of optionsOf(value.$by)) {
-      walk(Object.hasOwn(value.$of, option) ? value.$of[option] : absent, [...under2, [value.$by, option]]);
-    }
-  };
-  walk(held, []);
-  return out;
-}
-function prefsCss(store, options = {}) {
-  const root = options.root ?? ":root";
-  const property = options.property ?? ((path) => `--${kebab(path)}`);
-  const attribute = options.attribute ?? ((selector) => `data-${kebab(selector)}`);
-  const leaves = new Map([...prefLeaves(store.schema)].filter(([, leaf2]) => prefHoldsValue(leaf2)));
-  const selectors = prefSelectors(leaves);
-  const defaults = Object.fromEntries([...selectors.keys()].map((path) => [path, leaves.get(path).default]));
-  const base = store.values({ at: defaults });
-  const blocks = /* @__PURE__ */ new Map();
-  const declare = (under2, path, leaf2, value) => {
-    const name = property(path, leaf2);
-    if (name === null) return;
-    const given = options.value?.(value, leaf2, path);
-    const text = given === void 0 ? cssValue(leaf2, value) : given;
-    if (text === null) return;
-    const key = under2.map(([selector, option]) => `${selector}=${option}`).join("&");
-    if (!blocks.has(key)) blocks.set(key, { under: under2, lines: [] });
-    blocks.get(key).lines.push(`  ${name}: ${text};`);
-  };
-  for (const [path, leaf2] of leaves) {
-    declare([], path, leaf2, prefValueAtPath(base, path));
-    const own = selectors.get(path);
-    if (own) for (const option of own) declare([[path, option]], path, leaf2, option);
-    const held = store.locus(path);
-    if (!held) continue;
-    for (const { under: under2, value } of toldApart(held, (selector) => selectors.get(selector) ?? [], leaf2.default)) {
-      declare(under2, path, leaf2, value);
-    }
-  }
-  return [...blocks.values()].map((block, i) => ({ ...block, i })).sort((a, b) => a.under.length - b.under.length || a.i - b.i).map(({ under: under2, lines }) => {
-    const matched = under2.map(([selector, option]) => `[${attribute(selector)}=${quoted(option)}]`).join("");
-    return `:where(${root}${matched}) {
-${lines.join("\n")}
-}`;
-  }).join("\n\n");
-}
-function prefsCssAttributes(store, options = {}) {
-  const attribute = options.attribute ?? ((selector) => `data-${kebab(selector)}`);
-  const leaves = prefLeaves(store.schema);
-  return Object.fromEntries([...prefSelectors(leaves).keys()].map((path) => [attribute(path), store.get(path)]));
-}
-
 // src/aliasTargets.ts
 function visibleFieldsOf(leaf2) {
   if (leaf2.kind !== "object") return leaf2;
@@ -392,6 +323,9 @@ function prefType(name, leaf2) {
 }
 
 // src/groups.ts
+function prefAsBox(as) {
+  return as === "panel" || as === "menu";
+}
 function prefGroupIsPage(group) {
   return group.as === void 0 || group.as === "page";
 }
@@ -441,6 +375,7 @@ var PREF_KIND_TRAITS = {
   union: MANY,
   field: ONE,
   action: { compound: false, several: true },
+  actions: { compound: false, several: true },
   alias: ONE,
   label: ONE,
   separator: ONE
@@ -453,6 +388,28 @@ function prefDrawsSeveral(leaf2) {
   return traitsOf(leaf2).several;
 }
 
-export { PREF_ENTRY, PREF_KIND_TRAITS, PREF_SCOPE, applyPrefConditions, applyPrefEntryConditions, pairRuns, pref, prefAliasTargets, prefDrawsSeveral, prefFitsHeading, prefGroupIsPage, prefHeadingKey, prefIsCompound, prefJudge, prefObjectBase, prefObjectWithField, prefReader, prefScopeAt, prefScopeUnder, prefShownReader, prefShownValue, prefTabRuns, prefType, prefsCss, prefsCssAttributes };
+// src/merge.ts
+function mergeChildren(into, from, at) {
+  for (const [key, child] of Object.entries(from)) {
+    const path = at === "" ? key : `${at}.${key}`;
+    const held = into[key];
+    if (held === void 0) {
+      into[key] = child;
+    } else if (!isPrefLeaf(held) && !isPrefLeaf(child)) {
+      const children = { ...held.children };
+      mergeChildren(children, child.children, path);
+      into[key] = { ...held, children };
+    } else {
+      throw new Error(`mergePrefGroups: two groups give "${path}", and one of them is a leaf`);
+    }
+  }
+}
+function mergePrefGroups(name, ...groups) {
+  const children = {};
+  for (const group of groups) mergeChildren(children, group.children, "");
+  return { name, children };
+}
+
+export { PREF_ENTRY, PREF_KIND_TRAITS, PREF_SCOPE, applyPrefConditions, applyPrefEntryConditions, mergePrefGroups, pairRuns, pref, prefAliasTargets, prefAsBox, prefDrawsSeveral, prefFitsHeading, prefGroupIsPage, prefHeadingKey, prefIsCompound, prefJudge, prefLeafTags, prefLeavesTagged, prefObjectBase, prefObjectWithField, prefReader, prefScopeAt, prefScopeUnder, prefShownReader, prefShownValue, prefTabRuns, prefType };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map