@weasel-js/prefs 1.10.1 → 1.11.0

package/dist/{chunk-ASSX3JHY.js → chunk-WN6QQICK.js}

@@ -1,226 +1,7 @@
-import { formatUnit, unitScale } from '@weasel-js/quantity';
-import { isPlainObject, createEmitter } from '@weasel-js/registry';
-import { hexToRgba, interpolateSrgb, rgbaToHex } from '@weasel-js/paint';
+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 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 ?? ""}`) };
-  }
-  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) => storedOf(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";
@@ -324,6 +105,7 @@ var PREF_KINDS = {
   union: true,
   field: true,
   action: true,
+  actions: true,
   alias: true,
   label: true,
   separator: true
@@ -427,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") {
@@ -497,297 +281,28 @@ 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);
+
+// 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;
   };
-  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 };
+  return {
+    property: (path) => {
+      const rest = under2(path);
+      return rest === null ? null : `--wzl-kit-${kebab(rest)}`;
+    },
+    attribute: (selector) => `data-wzl-kit-${kebab(under2(selector) ?? selector)}`
   };
-  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) {
-  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/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`
     );
@@ -861,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`
       );
@@ -891,83 +406,6 @@ function watchPrefsVersion(cache, migrations) {
   };
 }
 
-// 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;
@@ -994,7 +432,7 @@ var encodeInfinity = (leaf, 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));
+    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) => {
@@ -1016,7 +454,7 @@ function prefWrites({ leaves, cache, selectors, version, selection, warnIfClosed
       return;
     }
     if (leaf.splitBy?.length && isPrefLocus(value)) {
-      store(path, mapLocusMembers(value, (member2) => encodeInfinity(leaf, member2)));
+      store(path, mapLocusMembers(value, (member) => encodeInfinity(leaf, member)));
       return;
     }
     const stored = encodeInfinity(leaf, value);
@@ -1175,6 +613,6 @@ function openPrefsCacheSync(options) {
 }
 var watch = (cache, options) => watchPrefsVersion(cache, options.migrations ?? []);
 
-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
+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