@weasel-js/prefs 1.10.0 → 1.11.0

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

@@ -1,211 +1,7 @@
-import { formatUnit, unitScale } from '@weasel-js/quantity';
-import { isPlainObject, createEmitter } from '@weasel-js/registry';
+import { isPrefSection, prefSectionLeaves, isPrefLeaf, kebab, prefLeaves, prefHoldsValue, checkPrefSplits, prefSelectors, createSnapshots, VERSION_RECORD, selectionAt, selectionWeights, resolveHeld, assignPrefValueAtPath, isPrefLocus, weightsUnder, recordValue, setOwnPrefValue, readRecord, stampRecord, joinLocus, splitLocus, mapLocusMembers, writeMember, prefVariantOf, repairLocus } from './chunk-OZFER7VN.js';
+import { createEmitter, isPlainObject } from '@weasel-js/registry';
 import { openRecords, openRecordsSync } from '@weasel-js/storage';
 
-// src/alias.ts
-function prefAliasTarget(alias, leafAt) {
-  const passed = /* @__PURE__ */ new Set();
-  let path = alias.of;
-  for (; ; ) {
-    if (passed.has(path)) return void 0;
-    passed.add(path);
-    const leaf = leafAt(path);
-    if (leaf === void 0) return void 0;
-    if (leaf.kind !== "alias") return { path, leaf };
-    path = leaf.of;
-  }
-}
-function prefAliasName(alias, target) {
-  if (alias.name !== "") return alias.name;
-  return target === void 0 ? "Alias" : target.name;
-}
-function prefAliasedLeaf(alias, target) {
-  return {
-    ...target,
-    name: prefAliasName(alias, target),
-    description: alias.description === "" ? target.description : alias.description
-  };
-}
-function isPrefLinearUnit(unit) {
-  return typeof unit.toDisplay !== "function";
-}
-var SHOWN = "shown";
-function resolvePrefUnit(unit) {
-  if (!isPrefLinearUnit(unit)) {
-    return { ...unit, format: unit.format ?? ((stored) => `${unit.toDisplay(stored)}${unit.suffix ?? ""}`) };
-  }
-  const { scale, offset = 0, precision, suffix, accepts } = unit;
-  const round = precision === void 0 ? void 0 : 10 ** precision;
-  const system = { base: "stored", units: { [SHOWN]: { factor: scale, offset } } };
-  return {
-    toDisplay: (stored) => {
-      const shown = (stored - offset) / scale;
-      return round === void 0 ? shown : Math.round(shown * round) / round;
-    },
-    fromDisplay: (shown) => shown * scale + offset,
-    format: (stored) => `${formatUnit(stored, SHOWN, system, { precision: precision ?? 2, suffix: false })}${suffix ?? ""}`,
-    ...suffix === void 0 ? {} : { suffix },
-    ...accepts === void 0 ? {} : { accepts }
-  };
-}
-function prefUnit(system, display, opts) {
-  let self;
-  try {
-    self = unitScale(system, display);
-  } catch (e) {
-    throw new Error(`prefUnit: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const suffix = opts?.suffix ?? display;
-  const accepts = { [suffix]: 1 };
-  for (const name of Object.keys(system.units)) {
-    const other = unitScale(system, name);
-    const factor = other.factor / self.factor;
-    const offset = (other.offset - self.offset) / self.factor;
-    accepts[name] = offset === 0 ? factor : { factor, offset };
-  }
-  return {
-    suffix,
-    scale: self.factor,
-    ...self.offset === 0 ? {} : { offset: self.offset },
-    accepts,
-    ...opts?.precision === void 0 ? {} : { precision: opts.precision }
-  };
-}
-
-// src/helpers.ts
-function prefDisplayBounds(p) {
-  if (!p.unit) return { min: p.min, max: p.max, step: p.step ?? 1 };
-  const { toDisplay } = resolvePrefUnit(p.unit);
-  const lo = p.min === void 0 ? void 0 : toDisplay(p.min);
-  const hi = p.max === void 0 ? void 0 : toDisplay(p.max);
-  const flipped = lo !== void 0 && hi !== void 0 && lo > hi;
-  const step = p.step === void 0 ? 1 : Math.abs(toDisplay(p.step) - toDisplay(0)) || p.step;
-  return { min: flipped ? hi : lo, max: flipped ? lo : hi, step };
-}
-function isPrefLeaf(node) {
-  return "kind" in node;
-}
-var VALUELESS = /* @__PURE__ */ new Set(["action", "alias", "label", "separator"]);
-function prefHoldsValue(leaf) {
-  return !VALUELESS.has(leaf.kind);
-}
-function isPrefSection(node) {
-  return !isPrefLeaf(node) && "members" in node;
-}
-function prefSectionLeaves(members) {
-  return Object.entries(members).flatMap(
-    ([key, child]) => isPrefLeaf(child) ? [[key, child]] : prefSectionLeaves(child.members)
-  );
-}
-function prefLeafAt(schema, path) {
-  if (isPrefSection(schema)) return prefSectionLeaves(schema.members).find(([key]) => key === path)?.[1];
-  let node = schema;
-  for (const seg of path.split(".")) {
-    if (isPrefLeaf(node) || !Object.hasOwn(node.children, seg)) return void 0;
-    node = node.children[seg];
-  }
-  return isPrefLeaf(node) ? node : void 0;
-}
-function prefValueAtPath(values, path) {
-  let cur = values;
-  for (const seg of path.split(".")) {
-    if (cur == null || typeof cur !== "object" || !Object.hasOwn(cur, seg)) return void 0;
-    cur = cur[seg];
-  }
-  return cur;
-}
-function visibleFields(fields, keepEmpty) {
-  const out = {};
-  for (const [key, child] of Object.entries(fields)) {
-    if (isPrefLeaf(child)) {
-      const kept = visiblePrefSubtree(child, false, keepEmpty);
-      if (kept) out[key] = kept;
-      continue;
-    }
-    const members = visibleFields(child.members, keepEmpty);
-    if (Object.keys(members).length > 0 || keepEmpty) out[key] = { ...child, members };
-  }
-  return out;
-}
-function visiblePrefSubtree(node, showHidden, keepEmpty = false) {
-  if (isPrefLeaf(node)) {
-    if (node.hidden && !showHidden) return null;
-    if (showHidden || node.kind !== "object") return node;
-    return { ...node, children: visibleFields(node.children, keepEmpty) };
-  }
-  const group = node;
-  const children = {};
-  for (const [key, child] of Object.entries(group.children)) {
-    const kept = visiblePrefSubtree(child, showHidden, keepEmpty);
-    if (kept) children[key] = kept;
-  }
-  if (Object.keys(children).length === 0 && !keepEmpty) return null;
-  return { ...node, children };
-}
-var VERSION_RECORD = "$version";
-function prefLeaves(schema) {
-  const out = /* @__PURE__ */ new Map();
-  const walk = (group, prefix) => {
-    for (const [key, child] of Object.entries(group.children)) {
-      if (key.includes(".")) {
-        throw new Error(`[prefs] schema key "${key}" contains "."; group keys are path segments`);
-      }
-      if (prefix === "" && key === VERSION_RECORD) {
-        throw new Error(`[prefs] schema key "${VERSION_RECORD}" is reserved`);
-      }
-      const path = prefix === "" ? key : `${prefix}.${key}`;
-      if (isPrefLeaf(child)) out.set(path, child);
-      else walk(child, path);
-    }
-  };
-  walk(schema, "");
-  return out;
-}
-function setOwnPrefValue(tree, key, value) {
-  Object.defineProperty(tree, key, { value, writable: true, enumerable: true, configurable: true });
-}
-function assignPrefValueAtPath(root, path, value) {
-  const parts = path.split(".");
-  let cursor = root;
-  for (const part of parts.slice(0, -1)) {
-    if (!Object.hasOwn(cursor, part) || cursor[part] == null) setOwnPrefValue(cursor, part, {});
-    cursor = cursor[part];
-  }
-  setOwnPrefValue(cursor, parts[parts.length - 1], value);
-}
-function flattenPrefValues(schema, tree) {
-  const out = [];
-  for (const path of prefLeaves(schema).keys()) {
-    const value = prefValueAtPath(tree, path);
-    if (value !== void 0) out.push([path, value]);
-  }
-  return out;
-}
-function prefLeafMatches(pref, path, query) {
-  if (pref.name.toLowerCase().includes(query)) return true;
-  if (pref.description?.toLowerCase().includes(query)) return true;
-  return path.toLowerCase().includes(query);
-}
-function filterPrefSubtree(node, query, path = "", over) {
-  const q = query.trim().toLowerCase();
-  if (q === "") return node;
-  const within = over ?? (isPrefLeaf(node) ? void 0 : node);
-  const find = (p) => within && prefLeafAt(within, p);
-  if (isPrefLeaf(node)) {
-    const target = node.kind === "alias" ? prefAliasTarget(node, find) : void 0;
-    const drawn = target ? prefAliasedLeaf(node, target.leaf) : node;
-    return prefLeafMatches(drawn, path, q) ? node : null;
-  }
-  const group = node;
-  if (group.name.toLowerCase().includes(q)) return node;
-  const children = {};
-  for (const [key, child] of Object.entries(group.children)) {
-    const kept = filterPrefSubtree(child, q, path === "" ? key : `${path}.${key}`, within);
-    if (kept) children[key] = kept;
-  }
-  if (Object.keys(children).length === 0) return null;
-  return { ...node, children };
-}
 var ORDERINGS = ["above", "below", "atLeast", "atMost"];
 var TEST_KEYS = /* @__PURE__ */ new Set(["path", "from", "is", "isNot", "in", ...ORDERINGS]);
 var isValue = (v) => v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean";
@@ -309,6 +105,7 @@ var PREF_KINDS = {
   union: true,
   field: true,
   action: true,
+  actions: true,
   alias: true,
   label: true,
   separator: true
@@ -412,12 +209,14 @@ function leafProblems(test, schema, site, over) {
   if (held === UNSEEN) return [];
   const { leaf } = held;
   const named = inEntry ? path === "" ? "the entry" : `the entry's "${path}"` : `"${path}"`;
-  if (!prefHoldsValue(leaf)) return [{ code: "no-value", path, problem: `${named} is a${leaf.kind === "separator" || leaf.kind === "label" ? "" : "n"} ${leaf.kind}, which holds no value` }];
+  if (!prefHoldsValue(leaf)) return [{ code: "no-value", path, problem: `${named} is a${leaf.kind === "separator" || leaf.kind === "label" ? "" : "n"} ${leaf.kind === "actions" ? "actions leaf" : leaf.kind}, which holds no value` }];
   const out = [];
   const compared = [test.is, test.isNot, ...test.in ?? []].filter((value) => value !== void 0);
   for (const value of compared) {
     const why = neverHolds(leaf, value);
-    if (why !== void 0) out.push({ code: "value", path, problem: `${named} never holds ${show(value)}: ${why}` });
+    if (why === void 0) continue;
+    const code = leaf.kind === "enum" && typeof value === "string" ? "option" : "value";
+    out.push({ code, path, problem: `${named} never holds ${show(value)}: ${why}` });
   }
   const ordering = ORDERINGS.find((op) => test[op] !== void 0);
   if (ordering !== void 0 && isBuiltinPref(leaf) && leaf.kind !== "number") {
@@ -483,121 +282,27 @@ function checkPrefConditions(schema, over) {
   return out;
 }
 
-// src/union.ts
-function prefVariantOf(leaf, value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const key = value[leaf.tag];
-  if (typeof key !== "string" || !Object.hasOwn(leaf.variants, key)) return void 0;
-  return [key, leaf.variants[key]];
-}
-function prefVariantDefault(leaf, key) {
-  const held = leaf.variants[key]?.default;
-  const fields = held !== null && typeof held === "object" ? held : {};
-  return { ...fields, [leaf.tag]: key };
-}
-function repairPrefValue(leaf, stored, validators) {
-  if (leaf.kind === "number") {
-    if (stored === "Infinity") stored = Infinity;
-    else if (stored === "-Infinity") stored = -Infinity;
-  }
-  const validate = validators?.[leaf.kind];
-  if (validate) {
-    try {
-      const out = validate(stored, leaf);
-      return out === void 0 ? leaf.default : out;
-    } catch {
-      return leaf.default;
-    }
-  }
-  switch (leaf.kind) {
-    case "number":
-      return repairNumber(leaf, stored);
-    case "boolean":
-      return leaf.encoding || typeof stored === "boolean" ? stored : leaf.default;
-    case "string":
-    case "color":
-    case "field":
-      return typeof stored === "string" ? stored : leaf.default;
-    case "enum": {
-      const e = leaf;
-      if (e.encoding) return stored;
-      return e.options.some((o) => o.value === stored) ? stored : leaf.default;
-    }
-    case "object":
-      if (isPlainObject(stored)) return repairFields(leaf, stored, validators);
-      return leaf.fromScalar ? stored : leaf.default;
-    case "map":
-      return repairMap(leaf, stored, validators);
-    case "union": {
-      const variant = prefVariantOf(leaf, stored);
-      return variant ? repairFields(variant[1], stored, validators) : leaf.default;
-    }
-    case "list":
-      return repairList(leaf, stored, validators);
-    default:
-      return stored;
-  }
-}
-function repairFields(leaf, stored, validators) {
-  let out;
-  for (const [key, field] of prefSectionLeaves(leaf.children)) {
-    if (!Object.hasOwn(stored, key) || stored[key] === void 0) continue;
-    const read = repairPrefValue(field, stored[key], validators);
-    if (read !== stored[key]) (out ??= { ...stored })[key] = read;
-  }
-  return out ?? stored;
-}
-function repairMap(leaf, stored, validators) {
-  if (!isPlainObject(stored)) return leaf.default;
-  const held = stored;
-  let out;
-  for (const [key, value] of Object.entries(held)) {
-    const read = repairPrefValue(leaf.item, value, validators);
-    if (read !== value) (out ??= { ...held })[key] = read;
-  }
-  return out ?? stored;
-}
-function repairList(leaf, stored, validators) {
-  if (!Array.isArray(stored)) return leaf.default;
-  if (leaf.minItems !== void 0 && stored.length < leaf.minItems) return leaf.default;
-  const kept = leaf.maxItems !== void 0 && stored.length > leaf.maxItems ? stored.slice(0, leaf.maxItems) : stored;
-  const read = kept.map((entry) => repairPrefValue(leaf.item, entry, validators));
-  return kept === stored && read.every((entry, i) => entry === stored[i]) ? stored : read;
-}
-function repairNumber(leaf, stored) {
-  if (typeof stored !== "number" || Number.isNaN(stored)) return leaf.default;
-  const { endless } = leaf;
-  if (stored === Infinity && (endless === "max" || endless === "both")) return stored;
-  if (stored === -Infinity && (endless === "min" || endless === "both")) return stored;
-  let v = stored;
-  if (leaf.min !== void 0 && v < leaf.min) v = leaf.min;
-  if (leaf.max !== void 0 && v > leaf.max) v = leaf.max;
-  return Number.isFinite(v) ? v : leaf.default;
-}
-
-// src/stamp.ts
-var isVersion = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
-function stampRecord(value, at) {
-  return { $at: at, value };
-}
-function isStampedRecord(record) {
-  if (record === null || typeof record !== "object") return false;
-  const keys = Object.keys(record);
-  return keys.length === 2 && Object.hasOwn(record, "value") && isVersion(record.$at);
-}
-function readRecord(record, unstamped) {
-  return isStampedRecord(record) ? { at: record.$at, value: record.value, stamped: true } : { at: unstamped, value: record, stamped: false };
-}
-function recordValue(record) {
-  return isStampedRecord(record) ? record.value : record;
+// src/kitCss.ts
+function kitSettingsCssOptions(at) {
+  const under2 = (path) => {
+    if (at === void 0 || at === "") return path;
+    return path.startsWith(`${at}.`) ? path.slice(at.length + 1) : null;
+  };
+  return {
+    property: (path) => {
+      const rest = under2(path);
+      return rest === null ? null : `--wzl-kit-${kebab(rest)}`;
+    },
+    attribute: (selector) => `data-wzl-kit-${kebab(under2(selector) ?? selector)}`
+  };
 }
 
 // src/migrate.ts
-var isVersion2 = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+var isVersion = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
 function runPrefsMigrations(cache, migrations, { stampAll = true } = {}) {
   const target = migrations.length;
   const raw = cache.get(VERSION_RECORD);
-  if (cache.has(VERSION_RECORD) && !isVersion2(raw)) {
+  if (cache.has(VERSION_RECORD) && !isVersion(raw)) {
     console.warn(
       `[prefs] "${cache.prefix}" has an unreadable ${VERSION_RECORD} (${JSON.stringify(raw)}); opening read-only`
     );
@@ -671,7 +376,7 @@ function watchPrefsVersion(cache, migrations) {
     if (!stopped && cache.writable) migrate();
   });
   const heard = (version) => {
-    if (!isVersion2(version)) {
+    if (!isVersion(version)) {
       console.warn(
         `[prefs] "${cache.prefix}" has an unreadable ${VERSION_RECORD} (${JSON.stringify(version)}) from another writer; no longer persisting`
       );
@@ -700,6 +405,8 @@ function watchPrefsVersion(cache, migrations) {
     stopChanges();
   };
 }
+
+// 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 +429,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), (member) => encodeInfinity(leaf, member));
+  };
+  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, (member) => encodeInfinity(leaf, member)));
+      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 +505,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 +520,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 +540,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 +560,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 +599,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 +613,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_KINDS, UNSEEN, checkPrefCondition, checkPrefConditions, createPrefsStore, isBuiltinPref, isPrefCondition, kitSettingsCssOptions, mapPrefConditionPaths, openPrefs, openPrefsCacheSync, openPrefsSync, pairRowsOf, prefConditionHolds, prefConditionPaths, prefConditionReadsItem, prefIsEnabled, prefIsShown, prefLeafHolding, prefLeafHoldingIn, prefSchemaHolding };
+//# sourceMappingURL=chunk-WN6QQICK.js.map
+//# sourceMappingURL=chunk-WN6QQICK.js.map