@weasel-js/prefs 1.10.1 → 1.11.0

package/dist/{open-C83pU7Va.d.ts → groups-BDZC-ywb.d.ts}

@@ -1,5 +1,5 @@
-import { StorageAdapter, SyncStorageAdapter } from '@weasel-js/storage';
-import { UnitEntry, UnitSystem, Unit, Display, InfinityText } from '@weasel-js/quantity';
+import { IconRef } from '@weasel-js/icons';
+import { UnitEntry, UnitSystem, Unit, UnitTable, Display, InfinityText } from '@weasel-js/quantity';
 
 /** What a condition can compare a leaf's value against. `null` stands for
  *  nothing held: a missing value as well as a stored `null`. */
@@ -107,6 +107,16 @@ interface PrefAction extends PrefBase<'action', undefined> {
      *  its tooltip. Unset: a button in a row, an icon in a bar. */
     control?: PrefActionControl;
 }
+/**
+ * Every action the host registered in the action group `group`, in registry
+ * order, each drawn as an {@link PrefAction} naming it would be: an action
+ * registered later appears without the schema changing. Holds no value, as
+ * an `action` holds none.
+ */
+interface PrefActions extends PrefBase<'actions', undefined> {
+    /** The registry action group whose actions are drawn. */
+    group: string;
+}
 
 /**
  * A second place for another leaf: its row draws that leaf's control and
@@ -135,9 +145,24 @@ declare function prefAliasTarget(alias: PrefAlias, leafAt: (path: string) => Pre
  * nothing.
  */
 declare function prefAliasName(alias: PrefAlias, target?: PrefLeaf): string;
-/** A leaf drawn through an alias: the target, under the alias's own name and description where it gives them. */
+/** A leaf drawn through an alias: the target, under the alias's own name, description and access letter where it gives them. */
 declare function prefAliasedLeaf(alias: PrefAlias, target: PrefLeaf): PrefLeaf;
 
+/** Reads a value held beside a number leaf, by the path a condition there would name. */
+type PrefBoundReader = (path: string) => unknown;
+/**
+ * A number leaf's bound where its value is held: `undefined` for none. Asked
+ * per holder, so each scene node a panel edits can have its own.
+ */
+type PrefBoundAt = (read: PrefBoundReader) => number | undefined;
+/**
+ * `leaf` with its `minAt` and `maxAt` read against `read` and folded into
+ * `min` and `max`, whichever is tighter. The leaf itself when it has neither.
+ */
+declare function prefNumberAt(leaf: PrefNumber, read: PrefBoundReader): PrefNumber;
+/** `n` held to `leaf`'s `min` and `max`, except an infinity an `endless` end stands for. */
+declare function prefClampNumber(leaf: PrefNumber, n: number): number;
+
 /**
  * A line of text among the rows, holding no value: `name` is the line and
  * `description` the note under it. A store neither reads nor writes one, and
@@ -156,7 +181,7 @@ type PrefSeparator = PrefBase<'separator', undefined>;
  * `default` is what a new entry starts as, and its `name` names one entry
  * (`'Phase'` under a list named `'Phases'`).
  */
-interface PrefList extends PrefBase<'list', readonly unknown[]> {
+interface PrefList extends PrefValueBase<'list', readonly unknown[]> {
     item: PrefLeaf;
     /** A stored list shorter than this reads as the default, and a UI stops removing at it. */
     minItems?: number;
@@ -197,7 +222,7 @@ declare function locusSelectors(stored: unknown): Set<string>;
  * `item` is an ordinary leaf of any kind; its `default` is what a new entry
  * starts as, and its `name` names one entry's value.
  */
-interface PrefMap extends PrefBase<'map', Readonly<Record<string, unknown>>> {
+interface PrefMap extends PrefValueBase<'map', Readonly<Record<string, unknown>>> {
     item: PrefLeaf;
 }
 
@@ -211,7 +236,8 @@ interface PrefMap extends PrefBase<'map', Readonly<Record<string, unknown>>> {
  * its `default` (without the tag) is what the value becomes when they choose
  * it. A stored value whose tag names no variant reads as the leaf's default.
  */
-interface PrefUnion extends PrefBase<'union', unknown> {
+interface PrefUnion extends PrefValueBase<'union', unknown> {
+    /** The field of the value that names its variant. Not one of `tags`. */
     tag: string;
     variants: Record<string, PrefObject>;
 }
@@ -261,6 +287,9 @@ type PrefNumberUnit = PrefLinearUnit | PrefFunctionUnit;
 interface ResolvedPrefUnit extends PrefFunctionUnit {
     format: (stored: number) => string;
 }
+/** What a unit leaf's field reads as typed text: its `accepts` table, and its
+ *  `suffix` as the display unit itself. */
+declare function prefUnitAccepts(unit: PrefNumberUnit): Readonly<UnitTable>;
 /** Whether `unit` is the data form, and so can be written out and edited. */
 declare function isPrefLinearUnit(unit: PrefNumberUnit): unit is PrefLinearUnit;
 /** How to convert and format with `unit`, whichever form it was written in. */
@@ -278,7 +307,7 @@ declare function prefUnit(system: UnitSystem, display: Unit, opts?: {
 }): PrefLinearUnit;
 
 /** The value types a built-in pref leaf can hold. */
-type PrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint' | 'object' | 'list' | 'map' | 'union' | 'field' | 'action' | 'alias' | 'label' | 'separator';
+type PrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint' | 'object' | 'list' | 'map' | 'union' | 'field' | 'action' | 'actions' | 'alias' | 'label' | 'separator';
 /** Leaves that share one row in a compact property UI, declared on the first
  *  of them. Purely presentational. */
 interface PrefPair {
@@ -298,6 +327,14 @@ interface PrefBase<K extends string, Value> {
     description: string;
     /** Fallback when nothing is persisted. */
     default: Value;
+    /** Words the leaf is also found by and gathered under: a settings search
+     *  matches them as it matches `name`, and `prefLeavesTagged` gathers every
+     *  leaf carrying one. A leaf also carries the tags of every group above it
+     *  (`prefLeafTags`). Unrelated to a union leaf's `tag`, which names the
+     *  field its value's variant is read from. */
+    tags?: readonly string[];
+    /** The letter that picks this in a menu, and with the menu bar's chord opens a top-level menu. One character; supported, never required. */
+    access?: string;
     /** Hide from a host app's settings UI by default. */
     hidden?: boolean;
     /** Drawn only while this holds. Presentational: the value stays stored
@@ -321,12 +358,11 @@ interface PrefBase<K extends string, Value> {
      *  fits there (`prefFitsHeading`); any other leaf stays a row. Honored by
      *  weasel-ui `PrefsForm` and labkit's `ControlPanel`. */
     heading?: boolean;
-    /** Glyph naming this leaf in a host UI's icon set (weasel-ui resolves it
-     *  against `ICON_PATHS`). A plain string because this package ships no
-     *  icon set and cannot depend on one. Read where a leaf's `name` has nowhere to go — a
+    /** Glyph naming this leaf. A name from `@weasel-js/icons`; this package draws
+     *  nothing. Read where a leaf's `name` has nowhere to go — a
      *  `pair`ed row is labeled by the pair, so its fields have only the glyph
      *  to tell them apart. */
-    icon?: string;
+    icon?: IconRef;
     /** Puts this leaf and the ones it names on one row. */
     pair?: PrefPair;
     /** Shorter forms of `name`, longest first. A surface short of room for
@@ -361,6 +397,11 @@ interface PrefBase<K extends string, Value> {
      *  what the leaf's value type is read from. */
     defaultLocus?: PrefLocus;
 }
+/** The fields every leaf holding a value shares, besides {@link PrefBase}'s. */
+interface PrefValueBase<K extends string, Value> extends PrefBase<K, Value> {
+    /** Drawn showing its value but not editable. */
+    readout?: boolean;
+}
 /** How a schema-driven UI should present a number pref. */
 type PrefNumberControl = 'input' | 'slider';
 /** How a schema-driven UI should present a boolean pref. */
@@ -369,11 +410,16 @@ type PrefBooleanControl = 'checkbox' | 'switch' | 'toggle';
 type PrefStringControl = 'input' | 'textarea';
 /** How a schema-driven UI should present an enum pref. */
 type PrefEnumControl = 'select' | 'radio' | 'toggle' | 'menu';
-/** A numeric pref, optionally bounded and stepped, and optionally stored in a
- *  different unit from the one shown. */
-interface PrefNumber extends PrefBase<'number', number> {
+/** What every number leaf carries; {@link PrefNumber} adds `clearable`. */
+interface PrefNumberBase extends PrefValueBase<'number', number | undefined> {
     min?: number;
     max?: number;
+    /** A lower bound read from where the value is held — a scene node's own
+     *  minimum — taken with `min`, the larger winning. A surface resolves it
+     *  per holder with `prefNumberAt`. */
+    minAt?: PrefBoundAt;
+    /** The upper counterpart of `minAt`, taken with `max`, the smaller winning. */
+    maxAt?: PrefBoundAt;
     step?: number;
     control?: PrefNumberControl;
     /** How the value shows, speaks and reads back when typed — `compact()`
@@ -385,6 +431,20 @@ interface PrefNumber extends PrefBase<'number', number> {
     /** The word infinity shows as — `'never'`, `'uncapped'`. Default `∞`. */
     infinity?: InfinityText;
 }
+/**
+ * A numeric pref, optionally bounded and stepped, and optionally stored in a
+ * different unit from the one shown.
+ *
+ * `clearable` says the field may hold no number, which a person sets by
+ * emptying it: the value is then `undefined`, which the owner reads as unset,
+ * and its default may be too.
+ */
+type PrefNumber = PrefNumberBase & ({
+    clearable?: false;
+    default: number;
+} | {
+    clearable: true;
+});
 /**
  * Stored-value bridge for a boolean leaf whose field is not a boolean — the
  * flag counterpart of {@link PrefEnumEncoding}. `TextStyle.fontStyle` is
@@ -397,12 +457,12 @@ interface PrefBooleanEncoding {
     write: (on: boolean, siblings: Record<string, unknown> | undefined) => unknown;
 }
 /** An on/off pref. */
-interface PrefBoolean extends PrefBase<'boolean', boolean> {
+interface PrefBoolean extends PrefValueBase<'boolean', boolean> {
     control?: PrefBooleanControl;
     encoding?: PrefBooleanEncoding;
 }
 /** A free-text pref. */
-interface PrefString extends PrefBase<'string', string> {
+interface PrefString extends PrefValueBase<'string', string> {
     control?: PrefStringControl;
 }
 /**
@@ -427,13 +487,11 @@ interface PrefEnumEncoding<T extends string = string> {
     write: (option: T, siblings: Record<string, unknown> | undefined) => unknown;
 }
 /** What every enum leaf carries; {@link PrefEnum} adds `clearable`. */
-interface PrefEnumBase<T extends string = string> extends PrefBase<'enum', T | undefined> {
+interface PrefEnumBase<T extends string = string> extends PrefValueBase<'enum', T | undefined> {
     /** `short` holds shorter forms of `label`, longest first, for a segmented
      *  control too narrow for the full one — down to a capital or two. `icon`
-     *  names a glyph in the host UI's set (weasel-ui resolves it against
-     *  `ICON_PATHS`), drawn in place of any text form where it resolves. It is
-     *  a plain string because this package ships no icon set and cannot
-     *  depend on one. The full `label` stays the accessible name, so neither the abbreviation nor the glyph becomes the only thing naming
+     *  names a glyph, drawn in place of any text form where it resolves. A name
+     *  from `@weasel-js/icons`; this package draws nothing. The full `label` stays the accessible name, so neither the abbreviation nor the glyph becomes the only thing naming
      *  the option.
      *
      *  `disabled` marks an option a control reports but cannot author — the
@@ -444,7 +502,7 @@ interface PrefEnumBase<T extends string = string> extends PrefBase<'enum', T | u
         value: T;
         label: string;
         short?: readonly string[];
-        icon?: string;
+        icon?: IconRef;
         disabled?: boolean;
     }[];
     control?: PrefEnumControl;
@@ -468,7 +526,7 @@ type PrefEnum<T extends string = string> = PrefEnumBase<T> & ({
 });
 /** A single color, stored as a hex string. For a value that may also be a
  *  gradient or a pattern, use {@link PrefPaint} instead. */
-interface PrefColor extends PrefBase<'color', string> {
+interface PrefColor extends PrefValueBase<'color', string> {
     /** Value is `#rrggbb`, or `#rrggbbaa` when `alpha` is set (UIs then
      *  offer an opacity control). */
     alpha?: boolean;
@@ -478,7 +536,7 @@ interface PrefColor extends PrefBase<'color', string> {
  * UIs dispatch it to an app-supplied renderer. Deliberately NOT
  * index-signatured so concrete app interfaces stay assignable.
  */
-type PrefCustom = PrefBase<string, unknown>;
+type PrefCustom = PrefValueBase<string, unknown>;
 /**
  * A whole `Paint`, not a color inside one. Use it wherever the value is
  * the tagged paint union — a solid color, a pattern, a gradient — rather
@@ -490,7 +548,7 @@ type PrefCustom = PrefBase<string, unknown>;
  * `'color' in paint` checks then paint flat solid. The union has to be
  * edited as a union.
  */
-interface PrefPaint extends PrefBase<'paint', unknown> {
+interface PrefPaint extends PrefValueBase<'paint', unknown> {
     /** Offer an opacity control alongside the color. */
     alpha?: boolean;
 }
@@ -506,7 +564,7 @@ interface PrefPaint extends PrefBase<'paint', unknown> {
  * edits that union. A child may also be a {@link PrefSection}, which
  * organizes the fields under a heading without contributing to the path.
  */
-interface PrefObject extends PrefBase<'object', unknown> {
+interface PrefObject extends PrefValueBase<'object', unknown> {
     children: Record<string, PrefLeaf | PrefSection>;
     /**
      * Lift a non-object value into the object form, for a consumer field that
@@ -521,13 +579,13 @@ interface PrefObject extends PrefBase<'object', unknown> {
  * value is read and written at (`'camera.type'`) — the currency fields refer
  * to each other in. A surface offers the fields it draws as the choices.
  */
-interface PrefField extends PrefBase<'field', string> {
+interface PrefField extends PrefValueBase<'field', string> {
     /** Only fields of these kinds may be named. Default: any leaf. */
     kinds?: readonly string[];
 }
 /** One built-in pref leaf. `PrefLeaf` widens this to include
  *  app-defined kinds. */
-type BuiltinPref = PrefNumber | PrefBoolean | PrefString | PrefEnum | PrefColor | PrefPaint | PrefObject | PrefList | PrefMap | PrefUnion | PrefField | PrefAction | PrefAlias | PrefLabel | PrefSeparator;
+type BuiltinPref = PrefNumber | PrefBoolean | PrefString | PrefEnum | PrefColor | PrefPaint | PrefObject | PrefList | PrefMap | PrefUnion | PrefField | PrefAction | PrefActions | PrefAlias | PrefLabel | PrefSeparator;
 /**
  * The built-in kinds, as a table. A kind added to {@link PrefKind} is a
  * compile error here, and from here it is one in every renderer's `never`
@@ -559,8 +617,11 @@ type PrefLeaf = BuiltinPref | PrefCustom;
  * `fragment` draws nothing of its own, so its rows sit among its neighbors'
  * as though they were written there. A fragment exists to hold things
  * together: one key for their values to nest under, one node to move.
+ * `bar` puts its prefs on one line in their bar forms. `menu` is drawn as
+ * a menu wherever a menu fits: on a bar, a button opening its contents as a
+ * menu; in a menu, a submenu; in a panel, a titled box as `panel` is.
  */
-type PrefGroupAs = 'page' | 'tab' | 'panel' | 'section' | 'fragment' | 'bar';
+type PrefGroupAs = 'page' | 'tab' | 'panel' | 'section' | 'fragment' | 'bar' | 'menu';
 /**
  * What a group or a section drawn `as: 'bar'` does with cells its line has no
  * room for: `scroll` keeps them all on it, and `menu` opens the ones past its
@@ -568,6 +629,8 @@ type PrefGroupAs = 'page' | 'tab' | 'panel' | 'section' | 'fragment' | 'bar';
  * has along the line, which is why it is asked for and not the default.
  */
 type PrefBarOverflow = 'scroll' | 'menu';
+/** What a bar's line starts with, ahead of its cells: `label` puts the bar's name there, and `icon` its `icon`. */
+type PrefBarLead = 'label' | 'icon';
 /** How a {@link PrefSection} is drawn. */
 type PrefSectionAs = Exclude<PrefGroupAs, 'page'>;
 /**
@@ -584,6 +647,9 @@ interface PrefGroup {
      *  reads as nothing without it). */
     name: string;
     description?: string;
+    /** Tags every leaf under the group carries besides its own. A settings
+     *  search matching one keeps the whole group, as matching its name does. */
+    tags?: readonly string[];
     /** How the group is drawn. Unset, its depth decides: a top-level group is a
      *  `page`, and one inside another is a `section`. */
     as?: PrefGroupAs;
@@ -591,6 +657,14 @@ interface PrefGroup {
      *  Unset: `scroll`. A surface that takes drops keeps every cell on the line
      *  whatever this says, so each is there to drop beside. */
     overflow?: PrefBarOverflow;
+    /** Drawn `as: 'bar'`: what its line starts with. Unset: its first cell. */
+    lead?: PrefBarLead;
+    /** Glyph naming the group, as a leaf's `icon` names the leaf. A bar drawn
+     *  with `lead: 'icon'` starts its line with it; the button a bar opens the
+     *  group from and its submenu row in a menu carry it beside its name. */
+    icon?: IconRef;
+    /** The letter that picks this in a menu, and with the menu bar's chord opens a top-level menu. One character; supported, never required. */
+    access?: string;
     /** Drawn, with everything under it, only while this holds. */
     showIf?: PrefCondition;
     /** Everything under it is disabled while this does not hold. */
@@ -609,6 +683,8 @@ interface PrefSection {
      *  {@link PrefGroup}. */
     name: string;
     description?: string;
+    /** As a {@link PrefGroup}'s. */
+    tags?: readonly string[];
     /** How the section is drawn, as a {@link PrefGroup}'s `as` — without
      *  `page`, since nothing that draws sections has a rail. Unset: a heading
      *  over its rows. */
@@ -616,211 +692,21 @@ interface PrefSection {
     /** As a {@link PrefGroup}'s. */
     overflow?: PrefBarOverflow;
     /** As a {@link PrefGroup}'s. */
+    lead?: PrefBarLead;
+    /** As a {@link PrefGroup}'s. */
+    icon?: IconRef;
+    /** As a {@link PrefGroup}'s. */
+    access?: string;
+    /** As a {@link PrefGroup}'s. */
     showIf?: PrefCondition;
     /** As a {@link PrefGroup}'s. */
     enableIf?: PrefCondition;
     members: Record<string, PrefLeaf | PrefSection>;
 }
+/** Whether a panel draws a group or a section drawn `as` this in a bordered, titled box: a `panel`, and a `menu`,
+ *  which a panel has no menu to open as. */
+declare function prefAsBox(as: PrefGroupAs | undefined): boolean;
 /** Whether a top-level group gets a page of its own, and not a place on the page of the root's own leaves. */
 declare function prefGroupIsPage(group: PrefGroup): boolean;
 
-/**
- * Folds a split value's alternatives into the one value read. `members` holds
- * two or more, each weighing more than nothing, and their weights need not
- * sum to 1.
- */
-type PrefBlend = (members: readonly PrefWeighted[], leaf: PrefLeaf) => unknown;
-/** The blends of the built-in kinds that have one. Every other kind takes its heaviest member. */
-declare const PREF_BLENDS: Readonly<Record<string, PrefBlend>>;
-
-type Join<A extends string, B extends string> = A extends '' ? B : `${A}.${B}`;
-/** Every value's dotted path in a `PrefGroup` schema, where a group's key is a
- *  segment; an `object` leaf is one path, its fields are not, and an `action`,
- *  `alias`, `label`, or `separator` leaf, holding no value, has none. A `PrefSection`
- *  has no such paths: each of its leaves is addressed by its own key. */
-type PrefPath<G, Prefix extends string = ''> = G extends {
-    children: infer C;
-} ? string extends keyof C ? Join<Prefix, string> : {
-    [K in keyof C & string]: C[K] extends {
-        kind: string;
-    } ? C[K] extends {
-        kind: 'action' | 'alias' | 'label' | 'separator';
-    } ? never : Join<Prefix, K> : C[K] extends {
-        children: Record<string, unknown>;
-    } ? PrefPath<C[K], Join<Prefix, K>> : never;
-}[keyof C & string] : never;
-/** The leaf at `P`. `unknown` under a group whose keys are not literal, as a
- *  schema built at run time has them: nothing says which leaf is there, so
- *  its value reads as `unknown`. */
-type PrefAtPath<G, P extends string> = G extends {
-    children: infer C;
-} ? string extends keyof C ? unknown : P extends `${infer H}.${infer Rest}` ? H extends keyof C ? C[H] extends {
-    kind: string;
-} ? never : PrefAtPath<C[H], Rest> : never : P extends keyof C ? C[P] extends {
-    kind: string;
-} ? C[P] : never : never : never;
-type AllOf<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-/** The fields an `object` leaf's `children` describe, sections folded in. Each is optional: an object may omit any. */
-type PrefFieldsOf<C> = {
-    [K in keyof C as C[K] extends {
-        kind: string;
-    } ? K : never]?: PrefValueOf<C[K]>;
-} & AllOf<{
-    [K in keyof C]: C[K] extends {
-        members: infer M;
-    } ? PrefFieldsOf<M> : never;
-}[keyof C]>;
-/** What a leaf holds: its kind's value type for a built-in kind, the type of
- *  its `default` for an app-defined one. A list holds an array of what its
- *  `item` holds, a map a record of it, and a union one variant's fields
- *  under that variant's tag — where the schema keeps `tag` a literal
- *  (`tag: 'type' as const`); one widened to `string` is typed by its default. */
-type PrefValueOf<L> = L extends {
-    kind: 'number';
-} ? number : L extends {
-    kind: 'boolean';
-} ? boolean : L extends {
-    kind: 'string' | 'color' | 'field';
-} ? string : L extends {
-    kind: 'paint';
-} ? unknown : L extends {
-    kind: 'enum';
-    options: readonly {
-        value: infer T;
-    }[];
-} ? L extends {
-    clearable: true;
-} ? T | undefined : T : L extends {
-    kind: 'list';
-    item: infer I;
-} ? PrefValueOf<I>[] : L extends {
-    kind: 'map';
-    item: infer I;
-} ? Record<string, PrefValueOf<I>> : L extends {
-    kind: 'union';
-    tag: infer T extends string;
-    variants: infer V;
-    default: infer D;
-} ? string extends keyof V | T ? D : {
-    [K in keyof V & string]: {
-        [P in T]: K;
-    } & (V[K] extends {
-        children: infer C;
-    } ? PrefFieldsOf<C> : unknown);
-}[keyof V & string] : L extends {
-    default: infer D;
-} ? D : unknown;
-/** What the leaf at `P` holds. */
-type PrefValueAt<G, P extends string> = PrefValueOf<PrefAtPath<G, P>>;
-
-/** Takes stored values from one version to the next: rename, transform or
- *  delete entries in `records`, keyed by leaf path. It sees the values, not
- *  the stamps they are stored under, and only those at its own version. */
-type PrefsMigration = (records: Map<string, unknown>) => void;
-
-/** Decides what a stored value reads as for one kind of leaf: the value to
- *  read, or `undefined` for "invalid, read the default". */
-type PrefValidator = (stored: unknown, leaf: PrefLeaf) => unknown;
-/** What `stored` reads as for `leaf`. Never writes anything back: a schema
- *  rolled back finds the original still in storage. */
-declare function repairPrefValue(leaf: PrefLeaf, stored: unknown, validators?: Readonly<Record<string, PrefValidator>>): unknown;
-
-/** One leaf changing, as a store subscriber hears it: the value readers now
- *  see, and whether this store or another writer made the change. */
-interface PrefChange {
-    path: string;
-    value: unknown;
-    origin: 'local' | 'remote';
-}
-/** Values for one schema, held in memory and persisted behind. */
-interface PrefsStore<S extends PrefGroup> {
-    readonly schema: S;
-    /**
-     * The leaf's value, repaired against the schema; its default when unset. A
-     * split value is folded: under the selectors' own values it is the member
-     * they name, and under `weights` it is the blend its kind makes of the
-     * members that weigh something. A selector `weights` leaves out keeps its
-     * own value.
-     */
-    get<P extends PrefPath<S>>(path: P, read?: {
-        weights?: PrefWeights;
-    }): PrefValueAt<S, P>;
-    /** On a split leaf, writes the member the selectors' own values name, or
-     *  with `at` the one named with each selector there set to the option given.
-     *  A {@link PrefLocus} given as the value replaces the whole of what is held. */
-    set<P extends PrefPath<S>>(path: P, value: PrefValueAt<S, P> | PrefLocus, write?: {
-        at?: PrefSelection;
-    }): void;
-    /** Hold the leaf's value once per option of the selector at `by`, one of
-     *  the leaf's `splitBy`, each option starting as the value it had. */
-    split(path: PrefPath<S>, by: string): void;
-    /** Stop splitting the leaf's value by the selector at `by`, keeping the
-     *  member that selector's own value names. */
-    join(path: PrefPath<S>, by: string): void;
-    /** What the leaf holds where its value is split, each member repaired. */
-    locus(path: PrefPath<S>): PrefLocus | undefined;
-    /** What every split leaf holds, by its path. The same map until something changes. */
-    loci(): ReadonlyMap<string, PrefLocus>;
-    /** Unset every leaf at or under `path`; with no path, all. */
-    reset(path?: string): void;
-    /** Whether the leaf has a value of its own rather than following its default. */
-    isSet(path: PrefPath<S>): boolean;
-    /** Every leaf's value as a nested tree. The same object until something
-     *  changes. With `at`, the tree as it would read with each selector named
-     *  there set to the option given, built for the call. */
-    values(read?: {
-        at?: PrefSelection;
-    }): Record<string, unknown>;
-    /** The leaves following their default. The same set until something changes. */
-    unset(): ReadonlySet<string>;
-    /** Every stored record as a nested tree, unrepaired, including records no
-     *  leaf describes. The same object until something changes. */
-    stored(): Record<string, unknown>;
-    /** `changes` is empty when only records no leaf describes changed. A
-     *  selector changing is a change to every leaf split by it. */
-    subscribe(listener: (changes: PrefChange[]) => void): () => void;
-    /** False while the store cannot persist: storage has not been read yet, or
-     *  was written by a newer schema. Changes still apply for this session, and
-     *  ones made before a late read lands are persisted when it does. False for
-     *  good once the store is closed. */
-    readonly writable: boolean;
-    /** True once `close` was called. A write after that changes what this store
-     *  reads and reaches neither storage nor its subscribers, and the first one
-     *  warns. */
-    readonly closed: boolean;
-    /** Try again now to read storage that could not be read at open, ahead of
-     *  the store's own retries. Resolves whether storage has been read. */
-    read(): Promise<boolean>;
-    /** Resolves once storage has been read: at once for a store that opened
-     *  with its values, and when a later read lands for one that could not. */
-    whenRead(): Promise<void>;
-    /** Resolves true when every queued write reached storage. */
-    flush(): Promise<boolean>;
-    close(): Promise<void>;
-}
-
-/** Options for `openPrefs` and `openPrefsSync`. */
-interface PrefsOptions {
-    storage: StorageAdapter;
-    /** Prepended to every record's key: `'myapp.prefs.'`. */
-    prefix: string;
-    /** `migrations[i]` takes stored records from version `i` to `i + 1`. The
-     *  current version is `migrations.length`. */
-    migrations?: readonly PrefsMigration[];
-    /** Validators for app-defined kinds, keyed by `kind`. One given for a
-     *  built-in kind replaces that kind's own rule. */
-    validators?: Readonly<Record<string, PrefValidator>>;
-    /** How a split value's alternatives fold into one for app-defined kinds,
-     *  keyed by `kind`. One given for a built-in kind replaces that kind's
-     *  own. A kind with none takes its heaviest alternative. */
-    blends?: Readonly<Record<string, PrefBlend>>;
-}
-/** Load every stored value for `schema`, migrate it, and return the store. */
-declare function openPrefs<S extends PrefGroup>(schema: S, options: PrefsOptions): Promise<PrefsStore<S>>;
-/** `openPrefs` for an adapter that reads synchronously: the store is ready
- *  on return, so values can be read before anything renders. */
-declare function openPrefsSync<S extends PrefGroup>(schema: S, options: PrefsOptions & {
-    storage: SyncStorageAdapter;
-}): PrefsStore<S>;
-
-export { type PrefWeighted as $, type PrefBooleanEncoding as A, type BuiltinPref as B, type PrefChange as C, type PrefConditionValue as D, type PrefCustom as E, type PrefEnum as F, type PrefEnumControl as G, type PrefEnumEncoding as H, type PrefField as I, type PrefFunctionUnit as J, type PrefGroupAs as K, type PrefLabel as L, type PrefLinearUnit as M, type PrefNumberControl as N, type PrefNumberUnit as O, type PrefLeaf as P, type PrefPaint as Q, type PrefPair as R, type PrefPath as S, type PrefSectionAs as T, type PrefSeparator as U, type PrefStringControl as V, type PrefTest as W, type PrefUnion as X, type PrefValidator as Y, type PrefValueAt as Z, type PrefValueOf as _, type PrefGroup as a, type PrefWeights as a0, type PrefsMigration as a1, type PrefsOptions as a2, type PrefsStore as a3, type ResolvedPrefUnit as a4, isBuiltinPref as a5, isPrefCondition as a6, isPrefLinearUnit as a7, isPrefLocus as a8, mapPrefConditionPaths as a9, openPrefs as aa, openPrefsSync as ab, pairRowsOf as ac, prefAliasName as ad, prefAliasTarget as ae, prefAliasedLeaf as af, prefConditionHolds as ag, prefConditionPaths as ah, prefConditionReadsItem as ai, prefGroupIsPage as aj, prefIsEnabled as ak, prefIsShown as al, memberAt as am, locusSelectors as an, prefUnit as ao, prefVariantDefault as ap, prefVariantOf as aq, repairPrefValue as ar, resolvePrefUnit as as, type PrefSection as b, type PrefNumber as c, type PrefList as d, type PrefMap as e, type PrefCondition as f, type PrefConditionReader as g, type PrefBoolean as h, type PrefString as i, type PrefColor as j, type PrefEnumBase as k, type PrefSelection as l, type PrefLocus as m, type PrefAlias as n, type PrefObject as o, type PrefKind as p, PREF_BLENDS as q, PREF_KINDS as r, type PrefAction as s, type PrefActionContext as t, type PrefActionControl as u, type PrefAtPath as v, type PrefBarOverflow as w, type PrefBase as x, type PrefBlend as y, type PrefBooleanControl as z };
+export { type ResolvedPrefUnit as $, type PrefBoundAt as A, type BuiltinPref as B, type PrefBoundReader as C, type PrefConditionValue as D, type PrefCustom as E, type PrefEnum as F, type PrefEnumControl as G, type PrefEnumEncoding as H, type PrefField as I, type PrefFunctionUnit as J, type PrefGroupAs as K, type PrefLinearUnit as L, type PrefLocus as M, type PrefNumberBase as N, type PrefNumberControl as O, type PrefLeaf as P, type PrefNumberUnit as Q, type PrefPaint as R, type PrefPair as S, type PrefSectionAs as T, type PrefSelection as U, type PrefStringControl as V, type PrefTest as W, type PrefUnion as X, type PrefValueBase as Y, type PrefWeighted as Z, type PrefWeights as _, type PrefGroup as a, isBuiltinPref as a0, isPrefCondition as a1, isPrefLinearUnit as a2, isPrefLocus as a3, mapPrefConditionPaths as a4, pairRowsOf as a5, prefAliasName as a6, prefAliasTarget as a7, prefAliasedLeaf as a8, prefAsBox as a9, prefClampNumber as aa, prefConditionHolds as ab, prefConditionPaths as ac, prefConditionReadsItem as ad, prefGroupIsPage as ae, prefIsEnabled as af, prefIsShown as ag, memberAt as ah, locusSelectors as ai, prefNumberAt as aj, prefUnit as ak, prefUnitAccepts as al, prefVariantDefault as am, prefVariantOf as an, resolvePrefUnit as ao, type PrefSection as b, type PrefNumber as c, type PrefList as d, type PrefMap as e, type PrefCondition as f, type PrefConditionReader as g, type PrefBoolean as h, type PrefString as i, type PrefColor as j, type PrefEnumBase as k, type PrefAction as l, type PrefActions as m, type PrefLabel as n, type PrefSeparator as o, type PrefAlias as p, type PrefObject as q, type PrefKind as r, PREF_KINDS as s, type PrefActionContext as t, type PrefActionControl as u, type PrefBarLead as v, type PrefBarOverflow as w, type PrefBase as x, type PrefBooleanControl as y, type PrefBooleanEncoding as z };