@weasel-js/prefs 1.10.0 → 1.11.0

package/dist/{open-BEY-aOGe.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;
@@ -164,13 +189,40 @@ interface PrefList extends PrefBase<'list', readonly unknown[]> {
     maxItems?: number;
 }
 
+/**
+ * A leaf's value split by another leaf: one member for each option of the
+ * `enum` leaf at `$by`. A member may itself be a locus, by a second selector.
+ * The alternatives are folded by weight when the value is read, and a plain
+ * setting of the selector gives one of them all of it.
+ */
+interface PrefLocus {
+    /** The full path of the `enum` leaf whose options key `$of`. */
+    $by: string;
+    $of: Record<string, unknown>;
+}
+/** A value for each selector a read is made under: its path, then the option chosen. */
+type PrefSelection = Readonly<Record<string, string>>;
+/** A weight for each option of each selector, by the selector's path. An option left out weighs nothing. */
+type PrefWeights = Readonly<Record<string, Readonly<Record<string, number>>>>;
+/** One alternative of a split value, and its share of the whole. */
+interface PrefWeighted {
+    value: unknown;
+    weight: number;
+}
+/** Whether `value` is a {@link PrefLocus}: an object of exactly `$by` and `$of`. */
+declare function isPrefLocus(value: unknown): value is PrefLocus;
+/** The one member `selection` names. A selector it leaves out, or an option the locus holds nothing for, reads as `absent`. */
+declare function memberAt(stored: unknown, selection: PrefSelection, absent: unknown): unknown;
+/** The path of every selector `stored` is split by, outermost first. */
+declare function locusSelectors(stored: unknown): Set<string>;
+
 /**
  * A leaf whose value is an object keyed by strings nobody declared, every
  * value described by `item`: the keyed counterpart of a {@link PrefList}.
  * `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;
 }
 
@@ -184,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>;
 }
@@ -215,7 +268,8 @@ interface PrefLinearUnit extends PrefUnitText {
     /** The stored value a display of 0 stands for. Absent is 0. */
     offset?: number;
     /** Decimal places the shown value is rounded to. Absent, the value shows unrounded and formats to two places.
-     *  What is typed is stored unrounded either way. */
+     *  What is typed is stored unrounded either way: a decimal typed at a decimal `scale` is stored as the
+     *  decimal the two multiply to, without the dust of multiplying them in binary. */
     precision?: number;
 }
 /** A display unit as code, for a conversion that is not linear. It cannot be written to JSON or edited as data. */
@@ -233,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. */
@@ -250,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 {
@@ -270,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
@@ -288,12 +353,16 @@ interface PrefBase<K extends string, Value> {
      *  (weasel-ui `PrefsForm` honors this for leaves whose control brings
      *  its own chrome). */
     block?: 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
+    /** Draw the control in the heading of the group or section holding the
+     *  leaf, in place of a row of its own. Only a built-in `boolean` or `enum`
+     *  fits there (`prefFitsHeading`); any other leaf stays a row. Honored by
+     *  weasel-ui `PrefsForm` and labkit's `ControlPanel`. */
+    heading?: boolean;
+    /** 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
@@ -314,6 +383,24 @@ interface PrefBase<K extends string, Value> {
      *  schema editor shows such a leaf as one closed thing and prints the name
      *  in place of its literal. */
     type?: string;
+    /** The `enum` leaves this one's value may be split by, each by the full
+     *  path its value is read at: the value may then be held once per option
+     *  of any of them (a {@link PrefLocus}), which the store folds into the one
+     *  value read. Whether it is split is the stored value's to say. The
+     *  order is the order a value split by several is stored in, the first
+     *  outermost. Each must be a plain `enum`: not `clearable`, with no
+     *  `encoding`, and not split itself. */
+    splitBy?: readonly string[];
+    /** What the leaf holds while nothing is stored for it, where that is a
+     *  split value: a default that differs by option. Split only by entries of
+     *  `splitBy`. `default` stays what a member it leaves out reads as, and
+     *  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';
@@ -323,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()`
@@ -339,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
@@ -351,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;
 }
 /**
@@ -381,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
@@ -398,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;
@@ -422,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;
@@ -432,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
@@ -444,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;
 }
@@ -460,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
@@ -475,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`
@@ -513,8 +617,20 @@ 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' | '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
+ * end from a button there. A bar set to `menu` takes all the room its host
+ * has along the line, which is why it is asked for and not the default.
  */
-type PrefGroupAs = 'page' | 'tab' | 'panel' | 'section' | 'fragment' | 'bar';
+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'>;
 /**
@@ -531,9 +647,24 @@ 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;
+    /** Drawn `as: 'bar'`: what happens to the cells its line has no room for.
+     *  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. */
@@ -552,173 +683,30 @@ 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. */
     as?: PrefSectionAs;
     /** 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;
 
-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`. */
-type PrefAtPath<G, P extends string> = G extends {
-    children: infer C;
-} ? 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. */
-    get<P extends PrefPath<S>>(path: P): PrefValueAt<S, P>;
-    set<P extends PrefPath<S>>(path: P, value: PrefValueAt<S, P>): void;
-    /** 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. */
-    values(): 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. */
-    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>>;
-}
-/** 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 { isPrefCondition as $, type PrefEnumEncoding as A, type BuiltinPref as B, type PrefField as C, type PrefFunctionUnit as D, type PrefGroupAs as E, type PrefLabel as F, type PrefLinearUnit as G, type PrefNumberControl as H, type PrefNumberUnit as I, type PrefPaint as J, type PrefPair as K, type PrefPath as L, type PrefSectionAs as M, type PrefSeparator as N, type PrefString as O, type PrefLeaf as P, type PrefStringControl as Q, type PrefTest as R, type PrefUnion as S, type PrefValidator as T, type PrefValueAt as U, type PrefValueOf as V, type PrefsMigration as W, type PrefsOptions as X, type PrefsStore as Y, type ResolvedPrefUnit as Z, isBuiltinPref as _, type PrefGroup as a, isPrefLinearUnit as a0, mapPrefConditionPaths as a1, openPrefs as a2, openPrefsSync as a3, pairRowsOf as a4, prefAliasName as a5, prefAliasTarget as a6, prefAliasedLeaf as a7, prefConditionHolds as a8, prefConditionPaths as a9, prefConditionReadsItem as aa, prefGroupIsPage as ab, prefIsEnabled as ac, prefIsShown as ad, prefUnit as ae, prefVariantDefault as af, prefVariantOf as ag, repairPrefValue as ah, resolvePrefUnit as ai, 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 PrefAlias as h, type PrefObject as i, type PrefKind as j, PREF_KINDS as k, type PrefAction as l, type PrefActionContext as m, type PrefActionControl as n, type PrefAtPath as o, type PrefBase as p, type PrefBoolean as q, type PrefBooleanControl as r, type PrefBooleanEncoding as s, type PrefChange as t, type PrefColor as u, type PrefConditionValue as v, type PrefCustom as w, type PrefEnum as x, type PrefEnumBase as y, type PrefEnumControl 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 };