@weasel-js/prefs 1.10.0 → 1.10.1

package/README.md

@@ -9,6 +9,22 @@ store.get('view.gridVisible');
 store.set('view.gridVisible', false);
 ```
 
+A schema is plain data, and `pref` writes it shorter:
+
+```ts
+const SCHEMA = pref.group('Prefs', {
+  view: pref.group('View', {
+    gridVisible: pref.boolean('Grid', true),
+    gridGap: pref.number('Grid gap', 8, { min: 2, max: 64, unit: { scale: 1, suffix: 'px' } }),
+    mode: pref.enum('Mode', 'dark', ['dark', 'light']),
+  }),
+});
+```
+
+Each builder returns what the literal would hold (`{ name, children }` for a
+group, `{ kind, name, description, default, … }` for a leaf), so paths and
+value types are read from it the same way, and the two can be mixed.
+
 One record per leaf. A leaf with no record follows its schema default. Reads
 repair stored values that no longer fit the schema without writing them back.
 `migrations[i]` takes stored records from version `i` to `i + 1`.
@@ -35,3 +51,87 @@ draws it there. Put an unlimited setting at the end of the range it is nearest:
 a 0–100% limit is off at 100, and a scale with no such end takes `endless`,
 which adds a stop one step past the range that stores `Infinity` and reads the
 leaf's `infinity` word.
+
+## Split values
+
+A leaf that lists `splitBy` may hold its value once per option of another
+leaf, where it would hold one. The other leaf, the selector, is an ordinary
+`enum` named by its path:
+
+```ts
+'look.mode': { kind: 'enum', default: 'dark', options: [dark, light], … }
+'gap':       { kind: 'number', default: 4, splitBy: ['look.mode'], … }
+
+store.split('gap', 'look.mode');   // holds { $by: 'look.mode', $of: { dark: 4, light: 4 } }
+store.set('gap', 8);               // writes the member the mode is set to
+store.set('look.mode', 'light');   // a change to every leaf split by it
+store.join('gap', 'look.mode');    // back to one value: the member the mode is set to
+```
+
+The stored value is a locus, `{ $by, $of }`, and a member may itself be split
+by a second selector. `store.get` reads the member the selectors are set to.
+`store.get(path, { weights })` reads the alternatives folded by weight, which
+is what a transition between two options shows on the way:
+
+```ts
+store.get('gap', { weights: { 'look.mode': { dark: 0.25, light: 0.75 } } });
+```
+
+A number blends linearly and a color blends in OKLCH. Every other kind takes
+its heaviest alternative, the first option on a tie; `blends` in the open
+options says otherwise for a kind. `store.values({ at: { 'look.mode': 'light' } })`
+is the whole tree as it would read with the selectors set as given.
+
+`store.set(path, value, { at })` writes the member a stated choice names,
+whatever the selectors are set to, and `store.loci()` is what every split leaf
+holds, by path: one map until something changes. `usePrefsValues` returns
+both shaped for `PrefsForm`, with `split` and `join` beside them:
+
+```tsx
+const { values, set, loci, split, join, setAt } = usePrefsValues(store);
+<PrefsForm schema={schema} values={values} onChange={set}
+  loci={loci} onSplit={split} onJoin={join} onChangeAt={setAt} />
+```
+
+A leaf's default may be split too. `defaultLocus` is what the leaf holds while
+nothing is stored for it, and `default` stays what a member it leaves out
+reads as:
+
+```ts
+'gap': { kind: 'number', default: 4, splitBy: ['look.mode'],
+         defaultLocus: { $by: 'look.mode', $of: { dark: 4, light: 6 } }, … }
+
+store.get('gap');                                    // 4, or 6 once the mode is light
+store.set('gap', 8, { at: { 'look.mode': 'light' } }); // holds { dark: 4, light: 8 }
+store.reset('gap');                                  // the split default again
+```
+
+A selector must be a plain `enum`: not `clearable`, with no `encoding`, and
+not split itself. The store warns of a `splitBy` that names anything else when
+it opens.
+
+## As CSS custom properties
+
+`prefsCss(store)` writes the store's values as custom properties, and
+`prefsCssAttributes(store)` gives the attributes that pick its blocks:
+
+```css
+:where(:root) {
+  --look-mode: dark;
+  --gap: 4px;          /* a split value, at the member the selectors' defaults name */
+}
+
+:where(:root[data-look-mode='light']) {
+  --look-mode: light;
+  --gap: 6px;
+}
+```
+
+Every leaf is set on the root. A block follows for each choice of options a
+split value tells apart, and only those: a value that is one thing under
+`light` at every density gets one block for `light`. Every block is inside
+`:where()`, so a rule of the page's own wins, and blocks naming more selectors
+come later. A number is written in its display unit where the unit's suffix is
+a CSS unit, a boolean as `1` or `0`, an enum's option as an identifier, and a
+string quoted; a leaf of any other kind is left out unless the `value` option
+writes it. `root`, `property`, and `attribute` rename what it writes.

package/dist/{chunk-5KB3WBJZ.js → chunk-ASSX3JHY.js}

@@ -1,5 +1,6 @@
 import { formatUnit, unitScale } from '@weasel-js/quantity';
 import { isPlainObject, createEmitter } from '@weasel-js/registry';
+import { hexToRgba, interpolateSrgb, rgbaToHex } from '@weasel-js/paint';
 import { openRecords, openRecordsSync } from '@weasel-js/storage';
 
 // src/alias.ts
@@ -30,6 +31,20 @@ function isPrefLinearUnit(unit) {
   return typeof unit.toDisplay !== "function";
 }
 var SHOWN = "shown";
+function decimalPlaces(n) {
+  const text = String(n);
+  if (text.includes("e")) return void 0;
+  const dot = text.indexOf(".");
+  return dot === -1 ? 0 : text.length - dot - 1;
+}
+var DECIMAL_PLACES = 12;
+function storedOf(shown, scale, offset) {
+  const raw = shown * scale + offset;
+  const [a, b, c] = [decimalPlaces(shown), decimalPlaces(scale), decimalPlaces(offset)];
+  if (a === void 0 || b === void 0 || c === void 0 || !Number.isFinite(raw)) return raw;
+  const places = Math.max(a + b, c);
+  return places > DECIMAL_PLACES ? raw : Number(raw.toFixed(places));
+}
 function resolvePrefUnit(unit) {
   if (!isPrefLinearUnit(unit)) {
     return { ...unit, format: unit.format ?? ((stored) => `${unit.toDisplay(stored)}${unit.suffix ?? ""}`) };
@@ -42,7 +57,7 @@ function resolvePrefUnit(unit) {
       const shown = (stored - offset) / scale;
       return round === void 0 ? shown : Math.round(shown * round) / round;
     },
-    fromDisplay: (shown) => shown * scale + offset,
+    fromDisplay: (shown) => storedOf(shown, scale, offset),
     format: (stored) => `${formatUnit(stored, SHOWN, system, { precision: precision ?? 2, suffix: false })}${suffix ?? ""}`,
     ...suffix === void 0 ? {} : { suffix },
     ...accepts === void 0 ? {} : { accepts }
@@ -482,6 +497,181 @@ function checkPrefConditions(schema, over) {
   } else group(schema, "");
   return out;
 }
+function isPrefLocus(value) {
+  if (!isPlainObject(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 2 && typeof value.$by === "string" && isPlainObject(value.$of);
+}
+function selectionWeights(selection) {
+  return Object.fromEntries(Object.entries(selection).map(([path, option]) => [path, { [option]: 1 }]));
+}
+var member = (locus, option, absent) => Object.hasOwn(locus.$of, option) ? locus.$of[option] : absent;
+function weighLocus(stored, weights, absent) {
+  const out = [];
+  const walk = (value, weight) => {
+    if (!isPrefLocus(value)) {
+      out.push({ value, weight });
+      return;
+    }
+    for (const [option, share] of Object.entries(weights[value.$by] ?? {})) {
+      if (share > 0) walk(member(value, option, absent), weight * share);
+    }
+  };
+  walk(stored, 1);
+  return out;
+}
+function memberAt(stored, selection, absent) {
+  let value = stored;
+  while (isPrefLocus(value)) {
+    const option = selection[value.$by];
+    if (option === void 0) return absent;
+    value = member(value, option, absent);
+  }
+  return value;
+}
+function writeMember(stored, selection, next) {
+  if (!isPrefLocus(stored)) return next;
+  const option = selection[stored.$by];
+  if (option === void 0) return stored;
+  return { $by: stored.$by, $of: { ...stored.$of, [option]: writeMember(stored.$of[option], selection, next) } };
+}
+function splitLocus(stored, by, options, order) {
+  const across = (value) => ({ $by: by, $of: Object.fromEntries(options.map((option) => [option, value])) });
+  if (!isPrefLocus(stored)) return across(stored);
+  if (stored.$by === by) return stored;
+  if (order.indexOf(stored.$by) > order.indexOf(by)) return across(stored);
+  return mapMembers(stored, (inner) => splitLocus(inner, by, options, order));
+}
+function joinLocus(stored, by, selection, absent) {
+  if (!isPrefLocus(stored)) return stored;
+  if (stored.$by !== by) return mapMembers(stored, (inner) => joinLocus(inner, by, selection, absent));
+  const option = selection[by];
+  return option === void 0 ? absent : member(stored, option, absent);
+}
+function mapMembers(locus, fn) {
+  let out;
+  for (const [option, value] of Object.entries(locus.$of)) {
+    const next = fn(value);
+    if (next !== value) (out ??= { ...locus.$of })[option] = next;
+  }
+  return out ? { $by: locus.$by, $of: out } : locus;
+}
+function mapLocusMembers(stored, fn) {
+  return isPrefLocus(stored) ? mapMembers(stored, (inner) => mapLocusMembers(inner, fn)) : fn(stored);
+}
+function locusSelectors(stored) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (!isPrefLocus(value)) return;
+    out.add(value.$by);
+    for (const inner of Object.values(value.$of)) walk(inner);
+  };
+  walk(stored);
+  return out;
+}
+function repairLocus(stored, allowed, optionsOf, repairMember) {
+  const BAD = /* @__PURE__ */ Symbol("bad");
+  const walk = (value, met) => {
+    if (!isPrefLocus(value)) return repairMember(value);
+    const options = allowed.includes(value.$by) && !met.includes(value.$by) ? optionsOf(value.$by) : void 0;
+    if (!options) return BAD;
+    const of = {};
+    for (const option of options) {
+      if (!Object.hasOwn(value.$of, option)) continue;
+      const read2 = walk(value.$of[option], [...met, value.$by]);
+      if (read2 === BAD) return BAD;
+      of[option] = read2;
+    }
+    return { $by: value.$by, $of: of };
+  };
+  const read = walk(stored, []);
+  return read === BAD ? void 0 : read;
+}
+var heaviest = (members) => members.reduce((most, m) => m.weight > most.weight ? m : most).value;
+var blendNumber = (members, leaf) => {
+  let sum = 0;
+  let total = 0;
+  for (const { value, weight } of members) {
+    if (typeof value !== "number" || !Number.isFinite(value)) return heaviest(members);
+    sum += value * weight;
+    total += weight;
+  }
+  return sum / total;
+};
+var blendColor = (members, leaf) => {
+  let mixed;
+  let total = 0;
+  for (const { value, weight } of members) {
+    let next;
+    try {
+      next = hexToRgba(value);
+    } catch {
+      return heaviest(members);
+    }
+    total += weight;
+    if (!mixed) {
+      mixed = next;
+      continue;
+    }
+    const t = weight / total;
+    const [r, g, b] = interpolateSrgb([mixed[0], mixed[1], mixed[2]], [next[0], next[1], next[2]], t, "oklch");
+    mixed = [r, g, b, mixed[3] + (next[3] - mixed[3]) * t];
+  }
+  return rgbaToHex(mixed);
+};
+var PREF_BLENDS = { number: blendNumber, color: blendColor };
+function blendPref(leaf, members, blends) {
+  if (members.length === 0) return leaf.default;
+  if (members.length === 1) return members[0].value;
+  const blend = (blends && Object.hasOwn(blends, leaf.kind) ? blends[leaf.kind] : void 0) ?? (Object.hasOwn(PREF_BLENDS, leaf.kind) ? PREF_BLENDS[leaf.kind] : void 0) ?? heaviest;
+  return blend(members, leaf);
+}
+
+// src/splitCheck.ts
+var refusal = (leaf) => {
+  if (!leaf) return ["no-leaf", "names no leaf"];
+  if (leaf.kind !== "enum") return ["not-enum", `names a ${leaf.kind} leaf, and only an enum has options to split by`];
+  const selector = leaf;
+  if (selector.encoding) return ["encoded", "names an enum with an encoding, whose stored value is not its option"];
+  if (selector.clearable) return ["clearable", "names a clearable enum, which may hold none of its options"];
+  if (selector.splitBy?.length) return ["split", "names a leaf that may itself be split"];
+  return void 0;
+};
+function prefSelectors(leaves) {
+  const out = /* @__PURE__ */ new Map();
+  for (const leaf of leaves.values()) {
+    for (const path of leaf.splitBy ?? []) {
+      const selector = leaves.get(path);
+      if (out.has(path) || refusal(selector)) continue;
+      out.set(path, selector.options.map((option) => option.value));
+    }
+  }
+  return out;
+}
+function checkPrefSplits(schema) {
+  const leaves = prefLeaves(schema);
+  const out = [];
+  for (const [at, leaf] of leaves) {
+    for (const path of locusSelectors(leaf.defaultLocus)) {
+      if (leaf.splitBy?.includes(path)) continue;
+      out.push({ code: "default", at, path, problem: `its defaultLocus is split by "${path}", which its splitBy does not list` });
+    }
+    if (!leaf.splitBy?.length) continue;
+    if (!prefHoldsValue(leaf)) {
+      out.push({ code: "valueless", at, problem: `a ${leaf.kind} leaf holds no value to split` });
+      continue;
+    }
+    leaf.splitBy.forEach((path, i) => {
+      if (leaf.splitBy.indexOf(path) !== i) {
+        out.push({ code: "twice", at, path, problem: `"${path}" is listed twice` });
+        return;
+      }
+      const why = refusal(leaves.get(path));
+      if (why) out.push({ code: why[0], at, path, problem: `"${path}" ${why[1]}` });
+    });
+  }
+  return out;
+}
 
 // src/union.ts
 function prefVariantOf(leaf, value) {
@@ -700,6 +890,85 @@ function watchPrefsVersion(cache, migrations) {
     stopChanges();
   };
 }
+
+// src/snapshot.ts
+function readStored(source, leaf, stored) {
+  const repair = (value) => repairPrefValue(leaf, value, source.validators);
+  if (!leaf.splitBy?.length || !isPrefLocus(stored)) return repair(stored);
+  const read = repairLocus(stored, leaf.splitBy, (path) => source.selectors.get(path), repair);
+  return read === void 0 ? leaf.default : read;
+}
+function resolveHeld(source, leaf, held, weights) {
+  return isPrefLocus(held) ? blendPref(leaf, weighLocus(held, weights, leaf.default), source.blends) : held;
+}
+function createSnapshots(source) {
+  const { leaves, cache, selectors } = source;
+  let snapshot = null;
+  let previous = null;
+  const unsetLoci = /* @__PURE__ */ new Map();
+  const unsetHeld = (path, leaf) => {
+    if (leaf.defaultLocus === void 0) return leaf.default;
+    if (!unsetLoci.has(path)) unsetLoci.set(path, readStored(source, leaf, leaf.defaultLocus));
+    return unsetLoci.get(path);
+  };
+  const build = () => {
+    const held = /* @__PURE__ */ new Map();
+    const raw = /* @__PURE__ */ new Map();
+    const unset = /* @__PURE__ */ new Set();
+    for (const [path, leaf] of leaves) {
+      if (!cache.has(path)) {
+        held.set(path, unsetHeld(path, leaf));
+        unset.add(path);
+        continue;
+      }
+      const record = cache.get(path);
+      raw.set(path, record);
+      const same2 = previous?.raw.has(path) && previous.raw.get(path) === record;
+      held.set(path, same2 ? previous.held.get(path) : readStored(source, leaf, recordValue(record)));
+    }
+    previous = { raw, held };
+    const selection = {};
+    for (const path of selectors.keys()) selection[path] = held.get(path);
+    const weights = selectionWeights(selection);
+    const byPath = /* @__PURE__ */ new Map();
+    const splitBy = /* @__PURE__ */ new Map();
+    const loci = /* @__PURE__ */ new Map();
+    const tree = {};
+    for (const [path, leaf] of leaves) {
+      const value = held.get(path);
+      if (isPrefLocus(value)) loci.set(path, value);
+      for (const selector of locusSelectors(value)) splitBy.set(selector, [...splitBy.get(selector) ?? [], path]);
+      const read = resolveHeld(source, leaf, value, weights);
+      byPath.set(path, read);
+      assignPrefValueAtPath(tree, path, read);
+    }
+    return { byPath, held, loci, selection, splitBy, tree, unset };
+  };
+  return {
+    current: () => snapshot ??= build(),
+    peek: () => snapshot,
+    drop: () => {
+      snapshot = null;
+    }
+  };
+}
+function weightsUnder(selectors, selection, given) {
+  const out = {};
+  for (const [path, options] of selectors) {
+    const own = Object.hasOwn(given, path) ? given[path] : void 0;
+    out[path] = own ? Object.fromEntries(options.filter((option) => (own[option] ?? 0) > 0).map((option) => [option, own[option]])) : { [selection[path]]: 1 };
+  }
+  return out;
+}
+function selectionAt(selectors, selection, at) {
+  const out = { ...selection };
+  for (const [path, option] of Object.entries(at)) {
+    if (selectors.get(path)?.includes(option)) out[path] = option;
+  }
+  return out;
+}
+
+// src/storeWrites.ts
 var encodeInfinity = (leaf, value) => {
   if (leaf.kind === "number") return value === Infinity || value === -Infinity ? String(value) : value;
   if (leaf.kind === "list" && Array.isArray(value)) {
@@ -722,6 +991,58 @@ var encodeInfinity = (leaf, value) => {
   }
   return out ?? value;
 };
+function prefWrites({ leaves, cache, selectors, version, selection, warnIfClosed }) {
+  const unsetLocus = (leaf) => {
+    if (leaf.defaultLocus === void 0 || !leaf.splitBy?.length) return void 0;
+    return repairLocus(leaf.defaultLocus, leaf.splitBy, (by) => selectors.get(by), (member2) => encodeInfinity(leaf, member2));
+  };
+  const rawAt = (path, leaf) => cache.has(path) ? recordValue(cache.get(path)) : unsetLocus(leaf) ?? encodeInfinity(leaf, leaf.default);
+  const store = (path, stored) => {
+    cache.set(path, stored === void 0 ? void 0 : stampRecord(stored, version));
+  };
+  const splitOf = (path, by) => {
+    warnIfClosed(path);
+    const leaf = leaves.get(path);
+    const options = selectors.get(by);
+    if (leaf?.splitBy?.includes(by) && options) return { leaf, options };
+    console.warn(`[prefs] "${path}" cannot be split by "${by}"; ignoring`);
+    return void 0;
+  };
+  const set = (path, value, write) => {
+    warnIfClosed(path);
+    const leaf = leaves.get(path);
+    if (!leaf) {
+      console.warn(`[prefs] no leaf at "${path}"; ignoring the write`);
+      return;
+    }
+    if (leaf.splitBy?.length && isPrefLocus(value)) {
+      store(path, mapLocusMembers(value, (member2) => encodeInfinity(leaf, member2)));
+      return;
+    }
+    const stored = encodeInfinity(leaf, value);
+    const had = cache.has(path) ? recordValue(cache.get(path)) : unsetLocus(leaf);
+    const intoMember = stored !== void 0 && leaf.splitBy?.length && isPrefLocus(had);
+    const under2 = write?.at ? selectionAt(selectors, selection(), write.at) : selection();
+    store(path, intoMember ? writeMember(had, under2, stored) : stored);
+  };
+  const split = (path, by) => {
+    const found = splitOf(path, by);
+    if (!found) return;
+    const had = rawAt(path, found.leaf);
+    const next = splitLocus(had, by, found.options, found.leaf.splitBy);
+    if (next !== had) store(path, next);
+  };
+  const join = (path, by) => {
+    const found = splitOf(path, by);
+    if (!found) return;
+    const had = rawAt(path, found.leaf);
+    const next = joinLocus(had, by, selection(), encodeInfinity(found.leaf, found.leaf.default));
+    if (next !== had) store(path, next);
+  };
+  return { set, split, join };
+}
+
+// src/store.ts
 function storedRecords(cache) {
   const tree = {};
   const branches = new WeakSet([tree]);
@@ -746,37 +1067,14 @@ function storedRecords(cache) {
   }
   return tree;
 }
-function createPrefsStore(schema, cache, validators, onClose, version = 0) {
+function createPrefsStore(schema, cache, validators, onClose, version = 0, blends) {
   const leaves = new Map([...prefLeaves(schema)].filter(([, leaf]) => prefHoldsValue(leaf)));
   for (const { field, at, problem } of checkPrefConditions(schema)) {
     console.warn(`[prefs] ${field} of ${at === "" ? "the schema" : `"${at}"`}: ${problem}`);
   }
-  let snapshot = null;
-  let previous = null;
-  const build = () => {
-    const byPath = /* @__PURE__ */ new Map();
-    const raw = /* @__PURE__ */ new Map();
-    const unset = /* @__PURE__ */ new Set();
-    const tree = {};
-    for (const [path, leaf] of leaves) {
-      const has = cache.has(path);
-      let value;
-      if (!has) {
-        value = leaf.default;
-        unset.add(path);
-      } else {
-        const record = cache.get(path);
-        const stored = recordValue(record);
-        raw.set(path, record);
-        value = previous?.raw.has(path) && previous.raw.get(path) === record ? previous.byPath.get(path) : repairPrefValue(leaf, stored, validators);
-      }
-      byPath.set(path, value);
-      assignPrefValueAtPath(tree, path, value);
-    }
-    previous = { raw, byPath };
-    return { byPath, tree, unset };
-  };
-  const current = () => snapshot ??= build();
+  for (const { at, problem } of checkPrefSplits(schema)) console.warn(`[prefs] splitBy of "${at}": ${problem}`);
+  const source = { leaves, cache, selectors: prefSelectors(leaves), validators, blends };
+  const { current, peek, drop } = createSnapshots(source);
   let storedTree = null;
   let changed = createEmitter();
   const stopCache = cache.subscribe((changes) => {
@@ -784,10 +1082,16 @@ function createPrefsStore(schema, cache, validators, onClose, version = 0) {
     if (records.length === 0) return;
     storedTree = null;
     const mine = records.filter((c) => leaves.has(c.name));
-    if (mine.length > 0) snapshot = null;
+    const before = peek();
+    if (mine.length > 0) drop();
     const now = current();
-    const out = mine.map((c) => ({ path: c.name, value: now.byPath.get(c.name), origin: c.origin }));
-    changed.emit(out);
+    const origins = new Map(mine.map((c) => [c.name, c.origin]));
+    for (const c of mine) {
+      for (const path of [...before?.splitBy.get(c.name) ?? [], ...now.splitBy.get(c.name) ?? []]) {
+        if (!origins.has(path)) origins.set(path, c.origin);
+      }
+    }
+    changed.emit([...origins].map(([path, origin]) => ({ path, value: now.byPath.get(path), origin })));
   });
   let closed = false;
   let warned = false;
@@ -798,17 +1102,19 @@ function createPrefsStore(schema, cache, validators, onClose, version = 0) {
   };
   return {
     schema,
-    get: (path) => current().byPath.get(path),
-    set: (path, value) => {
-      warnIfClosed(path);
+    ...prefWrites({ leaves, cache, selectors: source.selectors, version, selection: () => current().selection, warnIfClosed }),
+    get: (path, read) => {
+      const now = current();
+      if (!read?.weights) return now.byPath.get(path);
       const leaf = leaves.get(path);
-      if (!leaf) {
-        console.warn(`[prefs] no leaf at "${path}"; ignoring the write`);
-        return;
-      }
-      const stored = encodeInfinity(leaf, value);
-      cache.set(path, stored === void 0 ? void 0 : stampRecord(stored, version));
+      const weights = weightsUnder(source.selectors, now.selection, read.weights);
+      return leaf ? resolveHeld(source, leaf, now.held.get(path), weights) : void 0;
     },
+    locus: (path) => {
+      const held = current().held.get(path);
+      return isPrefLocus(held) ? held : void 0;
+    },
+    loci: () => current().loci,
     reset: (path) => {
       warnIfClosed(path);
       for (const p of leaves.keys()) {
@@ -816,7 +1122,18 @@ function createPrefsStore(schema, cache, validators, onClose, version = 0) {
       }
     },
     isSet: (path) => cache.has(path),
-    values: () => current().tree,
+    values: (read) => {
+      const now = current();
+      if (!read?.at) return now.tree;
+      const selection = selectionAt(source.selectors, now.selection, read.at);
+      const weights = selectionWeights(selection);
+      const tree = {};
+      for (const [path, leaf] of leaves) {
+        const set = source.selectors.has(path) ? selection[path] : resolveHeld(source, leaf, now.held.get(path), weights);
+        assignPrefValueAtPath(tree, path, set);
+      }
+      return tree;
+    },
     unset: () => current().unset,
     stored: () => storedTree ??= storedRecords(cache),
     subscribe: (listener) => changed.subscribe(listener),
@@ -844,11 +1161,11 @@ async function openPrefs(schema, options) {
   const cache = await openRecords({ storage: options.storage, prefix: options.prefix });
   const stop = watch(cache, options);
   if (runPrefsMigrations(cache, options.migrations ?? [])) await cache.flush();
-  return createPrefsStore(schema, cache, options.validators, stop, options.migrations?.length ?? 0);
+  return createPrefsStore(schema, cache, options.validators, stop, options.migrations?.length ?? 0, options.blends);
 }
 function openPrefsSync(schema, options) {
   const { cache, stop } = openPrefsCacheSync(options);
-  return createPrefsStore(schema, cache, options.validators, stop, options.migrations?.length ?? 0);
+  return createPrefsStore(schema, cache, options.validators, stop, options.migrations?.length ?? 0, options.blends);
 }
 function openPrefsCacheSync(options) {
   const cache = openRecordsSync({ storage: options.storage, prefix: options.prefix });
@@ -858,6 +1175,6 @@ function openPrefsCacheSync(options) {
 }
 var watch = (cache, options) => watchPrefsVersion(cache, options.migrations ?? []);
 
-export { PREF_KINDS, UNSEEN, VERSION_RECORD, checkPrefCondition, checkPrefConditions, createPrefsStore, filterPrefSubtree, flattenPrefValues, isBuiltinPref, isPrefCondition, isPrefLeaf, isPrefLinearUnit, isPrefSection, mapPrefConditionPaths, openPrefs, openPrefsCacheSync, openPrefsSync, pairRowsOf, prefAliasName, prefAliasTarget, prefAliasedLeaf, prefConditionHolds, prefConditionPaths, prefConditionReadsItem, prefDisplayBounds, prefHoldsValue, prefIsEnabled, prefIsShown, prefLeafAt, prefLeafHolding, prefLeafHoldingIn, prefLeaves, prefSchemaHolding, prefSectionLeaves, prefUnit, prefValueAtPath, prefVariantDefault, prefVariantOf, repairPrefValue, resolvePrefUnit, visiblePrefSubtree };
-//# sourceMappingURL=chunk-5KB3WBJZ.js.map
-//# sourceMappingURL=chunk-5KB3WBJZ.js.map
+export { PREF_BLENDS, PREF_KINDS, UNSEEN, VERSION_RECORD, checkPrefCondition, checkPrefConditions, checkPrefSplits, createPrefsStore, filterPrefSubtree, flattenPrefValues, isBuiltinPref, isPrefCondition, isPrefLeaf, isPrefLinearUnit, isPrefLocus, isPrefSection, locusSelectors, mapPrefConditionPaths, memberAt, openPrefs, openPrefsCacheSync, openPrefsSync, pairRowsOf, prefAliasName, prefAliasTarget, prefAliasedLeaf, prefConditionHolds, prefConditionPaths, prefConditionReadsItem, prefDisplayBounds, prefHoldsValue, prefIsEnabled, prefIsShown, prefLeafAt, prefLeafHolding, prefLeafHoldingIn, prefLeaves, prefSchemaHolding, prefSectionLeaves, prefSelectors, prefUnit, prefValueAtPath, prefVariantDefault, prefVariantOf, repairPrefValue, resolvePrefUnit, visiblePrefSubtree };
+//# sourceMappingURL=chunk-ASSX3JHY.js.map
+//# sourceMappingURL=chunk-ASSX3JHY.js.map