@weasel-js/prefs 1.9.4 → 1.10.0

package/dist/index.js

@@ -1,160 +1,254 @@
-import { openRecords, openRecordsSync } from '@weasel-js/storage';
-import { isPlainObject } from '@weasel-js/registry';
-import { unitScale, formatUnit } from '@weasel-js/quantity';
+import { prefLeafHoldingIn, prefLeafHolding, prefSchemaHolding, UNSEEN, prefConditionHolds, prefValueAtPath, isPrefSection, prefSectionLeaves, isPrefLeaf, prefLeafAt, prefAliasTarget, prefAliasedLeaf, pairRowsOf, prefConditionReadsItem, visiblePrefSubtree } from './chunk-5KB3WBJZ.js';
+export { PREF_KINDS, VERSION_RECORD, checkPrefCondition, checkPrefConditions, filterPrefSubtree, flattenPrefValues, isBuiltinPref, isPrefCondition, isPrefLeaf, isPrefLinearUnit, isPrefSection, mapPrefConditionPaths, openPrefs, openPrefsSync, pairRowsOf, prefAliasName, prefAliasTarget, prefAliasedLeaf, prefConditionHolds, prefConditionPaths, prefConditionReadsItem, prefDisplayBounds, prefHoldsValue, prefIsEnabled, prefIsShown, prefLeafAt, prefLeaves, prefSchemaHolding, prefSectionLeaves, prefUnit, prefValueAtPath, prefVariantDefault, prefVariantOf, repairPrefValue, resolvePrefUnit, visiblePrefSubtree } from './chunk-5KB3WBJZ.js';
 
-// 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;
+// src/tabRuns.ts
+function prefTabRuns(items, isTab) {
+  const out = [];
+  let run;
+  for (const item of items) {
+    if (!isTab(item)) {
+      run = void 0;
+      out.push({ item });
+    } else if (run) {
+      run.push(item);
+    } else {
+      out.push({ tabs: run = [item] });
+    }
   }
+  return out;
 }
-function prefAliasedLeaf(alias, target) {
-  return {
-    ...target,
-    name: alias.name === "" ? target.name : alias.name,
-    description: alias.description === "" ? target.description : alias.description
+
+// src/shown.ts
+function prefShownValue(leaf, stored, siblings) {
+  if (leaf.kind !== "boolean" && leaf.kind !== "enum") return stored;
+  const { encoding } = leaf;
+  return encoding ? encoding.read(stored, siblings) : stored;
+}
+function prefShownReader(schema, read, item, over) {
+  return (path, from) => {
+    const stored = read(path, from);
+    const held = from === "item" ? item && prefLeafHoldingIn(item, path) : prefLeafHolding(prefSchemaHolding(schema, path, over), path);
+    if (held === void 0 || held === UNSEEN) return stored;
+    const object = held.within === void 0 ? void 0 : read(held.within, from);
+    return prefShownValue(held.leaf, stored, typeof object === "object" && object !== null ? object : void 0);
   };
 }
 
-// src/helpers.ts
-function prefDisplayBounds(p) {
-  if (!p.unit) return { min: p.min, max: p.max, step: p.step ?? 1 };
-  const { toDisplay } = 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)
-  );
+// src/judge.ts
+function entryValue({ item, value }, path) {
+  if (path === "") return value !== void 0 ? value : item.default;
+  const held = prefValueAtPath(value, path);
+  return held !== void 0 ? held : prefValueAtPath(item.default, path);
+}
+function prefJudge(schema, read, entry, over) {
+  const stored = (path, from) => from === "item" ? entry && entryValue(entry, path) : read(path);
+  const shown = prefShownReader(schema, stored, entry?.item, over);
+  return (condition) => prefConditionHolds(condition, shown);
+}
+function deferEntryConditions(holds) {
+  return (condition, field) => prefConditionReadsItem(condition) || holds(condition, field);
+}
+function prefReader(schema, values, over) {
+  const beyond = over && prefReader(over, values);
+  return (path) => {
+    const held = prefValueAtPath(values, path);
+    if (held !== void 0) return held;
+    if (beyond && prefSchemaHolding(schema, path, over) === over) return beyond(path);
+    if (isPrefSection(schema)) {
+      for (const [key, leaf] of prefSectionLeaves(schema.members)) {
+        if (path === key) return leaf.default;
+        if (path.startsWith(`${key}.`)) return prefValueAtPath(leaf.default, path.slice(key.length + 1));
+      }
+      return void 0;
+    }
+    const steps = path.split(".");
+    let node = schema;
+    for (let i = 0; i < steps.length; i++) {
+      if (!Object.hasOwn(node.children, steps[i])) return void 0;
+      const child = node.children[steps[i]];
+      if (!isPrefLeaf(child)) node = child;
+      else return i === steps.length - 1 ? child.default : prefValueAtPath(child.default, steps.slice(i + 1).join("."));
+    }
+    return void 0;
+  };
 }
-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];
+
+// src/scopeAt.ts
+var PREF_ENTRY = "*";
+var PREF_SCOPE = Object.freeze({ shown: true, enabled: true });
+function prefScopeUnder(above, node, holds) {
+  const shown = above.shown && (node.showIf === void 0 || holds(node.showIf, "showIf"));
+  const enabled = above.enabled && (node.enableIf === void 0 || holds(node.enableIf, "enableIf"));
+  return shown === above.shown && enabled === above.enabled ? above : { shown, enabled };
+}
+function scopeAmong(held, rest, above, holds) {
+  for (const [key, child] of Object.entries(held)) {
+    if (!isPrefLeaf(child)) {
+      const found = scopeAmong(child.members, rest, prefScopeUnder(above, child, holds), holds);
+      if (found) return found;
+    } else if (rest === key) return prefScopeUnder(above, child, holds);
+    else if (rest.startsWith(`${key}.`)) return scopeInside(child, rest.slice(key.length + 1), prefScopeUnder(above, child, holds), holds);
   }
-  return isPrefLeaf(node) ? node : void 0;
+  return 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];
+function scopeInside(leaf, rest, scope, holds) {
+  if (leaf.kind === "object") return scopeAmong(leaf.children, rest, scope, holds) ?? scope;
+  if (leaf.kind === "list" || leaf.kind === "map") {
+    const { item } = leaf;
+    if (item === void 0) return scope;
+    const inItem = deferEntryConditions(holds);
+    const entry = prefScopeUnder(scope, { enableIf: item.enableIf }, inItem);
+    const dot = rest.indexOf(".");
+    return dot < 0 ? entry : scopeInside(item, rest.slice(dot + 1), entry, inItem);
   }
-  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 };
+  if (leaf.kind !== "union") return scope;
+  for (const variant of Object.values(leaf.variants)) {
+    const found = scopeAmong(variant.children, rest, scope, holds);
+    if (found) return found;
   }
-  return out;
+  return scope;
 }
-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;
+function scopeAt(schema, path, holds) {
+  let scope = prefScopeUnder(PREF_SCOPE, schema, holds);
+  if (path === "") return scope;
+  if (isPrefSection(schema)) return scopeAmong(schema.members, path, scope, holds) ?? scope;
+  let node = schema;
+  const steps = path.split(".");
+  for (let i = 0; i < steps.length; i++) {
+    if (!Object.hasOwn(node.children, steps[i])) return scope;
+    const child = node.children[steps[i]];
+    scope = prefScopeUnder(scope, child, holds);
+    if (isPrefLeaf(child)) return i === steps.length - 1 ? scope : scopeInside(child, steps.slice(i + 1).join("."), scope, holds);
+    node = child;
   }
-  if (Object.keys(children).length === 0 && !keepEmpty) return null;
-  return { ...node, children };
+  return scope;
 }
-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 prefAliasScope(own, alias, over, holds) {
+  const target = prefAliasTarget(alias, (path) => prefLeafAt(over, path));
+  if (target === void 0) return own;
+  const theirs = scopeAt(over, target.path, holds);
+  const shown = own.shown && theirs.shown;
+  const enabled = own.enabled && theirs.enabled;
+  return shown === own.shown && enabled === own.enabled ? own : { shown, enabled };
 }
-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 prefScopeAt(schema, path, holds, { aliasOver, aliasHolds } = {}) {
+  const own = scopeAt(schema, path, holds);
+  const leaf = prefLeafAt(schema, path);
+  return leaf?.kind === "alias" ? prefAliasScope(own, leaf, aliasOver ?? schema, aliasHolds ?? holds) : own;
 }
-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);
+
+// src/scope.ts
+var under = (prefix, key) => prefix === "" ? key : `${prefix}.${key}`;
+function leafWalk({ keepEmpty, keepHidden, inItem, aliasOver, aliasHolds }) {
+  const disabled = /* @__PURE__ */ new Set();
+  const hidden = /* @__PURE__ */ new Set();
+  const leaf = (node, path, above, holds) => {
+    const own = prefScopeUnder(above, node, holds);
+    const scope = node.kind === "alias" && aliasOver ? prefAliasScope(own, node, aliasOver, aliasHolds ?? holds) : own;
+    return scope.shown || keepHidden ? inside(node, path, scope, holds) : null;
+  };
+  const inside = (node, path, scope, holds) => {
+    if (!scope.shown) hidden.add(path);
+    if (!scope.enabled) disabled.add(path);
+    if (node.kind === "object") {
+      const children = members(node.children, path, scope, holds);
+      return children === node.children ? node : { ...node, children };
+    }
+    if (node.kind === "list" || node.kind === "map") {
+      const { item } = node;
+      if (item === void 0) return node;
+      const entry = inside(item, under(path, PREF_ENTRY), prefScopeUnder(scope, { enableIf: item.enableIf }, inItem), inItem);
+      return entry === item ? node : { ...node, item: entry };
+    }
+    if (node.kind !== "union") return node;
+    const { variants } = node;
+    let changed = false;
+    const next = {};
+    for (const [key, variant] of Object.entries(variants)) {
+      const children = members(variant.children, path, scope, holds);
+      changed ||= children !== variant.children;
+      next[key] = children === variant.children ? variant : { ...variant, children };
+    }
+    return changed ? { ...node, variants: next } : node;
+  };
+  const members = (held, prefix, above, holds) => {
+    let changed = false;
+    const out = {};
+    for (const [key, child] of Object.entries(held)) {
+      const kept = isPrefLeaf(child) ? leaf(child, under(prefix, key), above, holds) : section(child, prefix, above, holds);
+      changed ||= kept !== child;
+      if (kept !== null) out[key] = kept;
+    }
+    return changed ? out : held;
+  };
+  const section = (node, prefix, above, holds) => {
+    const scope = prefScopeUnder(above, node, holds);
+    if (!scope.shown && !keepHidden) return null;
+    const kept = members(node.members, prefix, scope, holds);
+    if (kept === node.members) return node;
+    return Object.keys(kept).length === 0 && !keepEmpty ? null : { ...node, members: kept };
+  };
+  return { disabled, hidden, leaf, inside, members };
+}
+function applyPrefConditions(schema, holds, { keepEmpty = false, keepHidden = false, aliasOver, aliasHolds } = {}) {
+  const walk = leafWalk({ keepEmpty, keepHidden, inItem: deferEntryConditions(holds), aliasOver: aliasOver ?? schema, aliasHolds });
+  const { disabled, hidden } = walk;
+  const group = (node, path, above) => {
+    const scope2 = prefScopeUnder(above, node, holds);
+    if (!scope2.shown && !keepHidden) return null;
+    if (!scope2.shown && path !== "") hidden.add(path);
+    if (!scope2.enabled && path !== "") disabled.add(path);
+    let changed = false;
+    const children = {};
+    for (const [key, child] of Object.entries(node.children)) {
+      const at = under(path, key);
+      const kept2 = isPrefLeaf(child) ? walk.leaf(child, at, scope2, holds) : group(child, at, scope2);
+      changed ||= kept2 !== child;
+      if (kept2 !== null) children[key] = kept2;
+    }
+    if (!changed) return node;
+    return Object.keys(children).length === 0 && !keepEmpty && path !== "" ? null : { ...node, children };
+  };
+  if (!isPrefSection(schema)) return { shown: group(schema, "", PREF_SCOPE), disabled, hidden };
+  const scope = prefScopeUnder(PREF_SCOPE, schema, holds);
+  if (!scope.shown && !keepHidden) return { shown: null, disabled, hidden };
+  const kept = walk.members(schema.members, "", scope, holds);
+  return { shown: kept === schema.members ? schema : { ...schema, members: kept }, disabled, hidden };
+}
+var ALWAYS = () => true;
+function applyPrefEntryConditions(item, path, holds, { keepEmpty = false, keepHidden = false } = {}) {
+  const asked = (condition, field) => !prefConditionReadsItem(condition) || holds(condition, field);
+  const walk = leafWalk({ keepEmpty, keepHidden, inItem: ALWAYS });
+  const scope = prefScopeUnder(PREF_SCOPE, { enableIf: item.enableIf }, asked);
+  return { item: walk.inside(item, path, scope, asked), disabled: walk.disabled, hidden: walk.hidden };
 }
-function filterPrefSubtree(node, query, path = "", leafAt) {
-  const q = query.trim().toLowerCase();
-  if (q === "") return node;
-  const find = leafAt ?? ((p) => isPrefLeaf(node) ? void 0 : prefLeafAt(node, 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}`, find);
-    if (kept) children[key] = kept;
-  }
-  if (Object.keys(children).length === 0) return null;
-  return { ...node, children };
+
+// src/aliasTargets.ts
+function visibleFieldsOf(leaf) {
+  if (leaf.kind !== "object") return leaf;
+  const shown = visiblePrefSubtree({ ...leaf, hidden: false }, false, true);
+  return { ...leaf, children: shown.children };
+}
+function prefAliasTargets(over, judge, { showHidden = false, markHidden = false } = {}) {
+  const holds = judge();
+  let applied;
+  const get = () => applied ??= applyPrefConditions(over, holds, { keepEmpty: true, keepHidden: markHidden });
+  const leafAt = (path) => {
+    const { shown } = get();
+    const leaf = shown === null ? void 0 : prefLeafAt(shown, path);
+    return leaf === void 0 || showHidden ? leaf : visibleFieldsOf(leaf);
+  };
+  return {
+    holds,
+    leafAt,
+    shown: (alias) => {
+      const target = prefAliasTarget(alias, leafAt);
+      return target && { path: target.path, leaf: prefAliasedLeaf(alias, target.leaf) };
+    },
+    disabledAt: (path) => get().disabled.has(path),
+    ...markHidden ? { hiddenAt: (path) => get().hidden.has(path) } : {},
+    entryAt: (item, path, value) => applyPrefEntryConditions(item, path, judge({ item, value }), { keepHidden: markHidden })
+  };
 }
 
 // src/object.ts
@@ -170,19 +264,6 @@ function prefObjectWithField(pref, held, key, value) {
   return rest;
 }
 
-// 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 };
-}
-
 // src/type.ts
 function prefType(name, leaf) {
   return { ...leaf, type: name };
@@ -193,354 +274,21 @@ function prefGroupIsPage(group) {
   return group.as === void 0 || group.as === "page";
 }
 
-// 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;
-function runPrefsMigrations(cache, migrations, { stampAll = true } = {}) {
-  const target = migrations.length;
-  const raw = cache.get(VERSION_RECORD);
-  if (cache.has(VERSION_RECORD) && !isVersion2(raw)) {
-    console.warn(
-      `[prefs] "${cache.prefix}" has an unreadable ${VERSION_RECORD} (${JSON.stringify(raw)}); opening read-only`
-    );
-    cache.stopWriting();
-    return false;
+// src/pair.ts
+function pairRuns(items, leafOf) {
+  const leaves = items.map(leafOf);
+  const pairs = pairRowsOf(leaves.filter((entry) => entry !== void 0));
+  const keys = leaves.map((entry) => entry === void 0 ? void 0 : pairs.get(entry[0]));
+  const runs = [];
+  for (let i = 0; i < items.length; ) {
+    const pair = keys[i];
+    let j = i + 1;
+    while (pair !== void 0 && keys[j]?.key === pair.key) j += 1;
+    runs.push(j - i > 1 ? { items: items.slice(i, j), pair } : { items: [items[i]] });
+    i = j;
   }
-  const stored = cache.has(VERSION_RECORD) ? raw : 0;
-  const held = cache.entries().filter(([name]) => name !== VERSION_RECORD).map(([name, record]) => ({ name, ...readRecord(record, Math.min(stored, target)) }));
-  const newest = Math.max(stored, ...held.map((r) => r.at));
-  if (newest > target) {
-    console.warn(
-      `[prefs] "${cache.prefix}" was written at version ${newest}, newer than this build's ${target}; opening read-only`
-    );
-    cache.stopWriting();
-    return false;
-  }
-  if (!cache.writable) return false;
-  const at = new Map(held.filter((r) => r.at < target).map((r) => [r.name, r.at]));
-  const records = new Map(held.filter((r) => at.has(r.name)).map((r) => [r.name, structuredClone(r.value)]));
-  for (let v = Math.min(target, ...at.values()); v < target; v++) {
-    const due = new Map([...records].filter(([name]) => at.get(name) <= v));
-    const before = [...due.keys()];
-    try {
-      migrations[v](due);
-    } catch (error) {
-      console.warn(
-        `[prefs] migration ${v} \u2192 ${v + 1} for "${cache.prefix}" threw; opening read-only on the unmigrated records`,
-        error
-      );
-      cache.stopWriting();
-      return false;
-    }
-    for (const name of before) if (!due.has(name)) records.delete(name);
-    for (const [name, value] of due) {
-      records.set(name, value);
-      at.set(name, v + 1);
-    }
-  }
-  let wrote = false;
-  for (const r of held) {
-    if (at.has(r.name)) {
-      if (!records.has(r.name)) cache.delete(r.name);
-      wrote = true;
-    } else if (stampAll && !r.stamped) {
-      cache.set(r.name, stampRecord(r.value, target));
-      wrote = true;
-    }
-  }
-  for (const [name, value] of records) {
-    if (value === void 0) cache.delete(name);
-    else cache.set(name, stampRecord(value, target));
-  }
-  if (stored !== target) {
-    cache.set(VERSION_RECORD, target);
-    wrote = true;
-  }
-  return wrote;
-}
-function watchPrefsVersion(cache, migrations) {
-  const target = migrations.length;
-  let versioned = cache.has(VERSION_RECORD);
-  let stopped = false;
-  const migrate = () => {
-    const cleared = versioned && !cache.has(VERSION_RECORD);
-    if (cleared) cache.set(VERSION_RECORD, target);
-    else if (!runPrefsMigrations(cache, migrations, { stampAll: false })) return;
-    versioned = true;
-    void cache.flush();
-  };
-  void cache.whenRead().then(() => {
-    if (!stopped && cache.writable) migrate();
-  });
-  const heard = (version) => {
-    if (!isVersion2(version)) {
-      console.warn(
-        `[prefs] "${cache.prefix}" has an unreadable ${VERSION_RECORD} (${JSON.stringify(version)}) from another writer; no longer persisting`
-      );
-      cache.stopWriting();
-    } else if (version > target) {
-      console.warn(
-        `[prefs] "${cache.prefix}" was migrated to version ${version} by another writer; this build knows ${target}; no longer persisting`
-      );
-      cache.stopWriting();
-    }
-  };
-  const stopOverruled = cache.onOverruled((changes) => {
-    for (const [name, value] of changes) if (name === VERSION_RECORD && value !== void 0) heard(value);
-  });
-  const stopChanges = cache.subscribe((changes) => {
-    const remote = changes.filter((change) => change.origin === "remote");
-    for (const change of remote) {
-      if (change.name === VERSION_RECORD && change.value !== void 0) heard(change.value);
-    }
-    if (remote.length > 0 && cache.writable) migrate();
-    versioned ||= cache.has(VERSION_RECORD);
-  });
-  return () => {
-    stopped = true;
-    stopOverruled();
-    stopChanges();
-  };
-}
-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/store.ts
-var encodeInfinity = (leaf, value) => {
-  if (leaf.kind === "number") return value === Infinity || value === -Infinity ? String(value) : value;
-  if (leaf.kind === "list" && Array.isArray(value)) {
-    const { item } = leaf;
-    return value.map((entry) => encodeInfinity(item, entry));
-  }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
-  const held = value;
-  if (leaf.kind === "map") {
-    const { item } = leaf;
-    return Object.fromEntries(Object.entries(held).map(([key, entry]) => [key, encodeInfinity(item, entry)]));
-  }
-  const fields = leaf.kind === "union" ? prefVariantOf(leaf, held)?.[1] : leaf;
-  if (fields?.kind !== "object") return value;
-  let out;
-  for (const [key, field] of prefSectionLeaves(fields.children)) {
-    if (!Object.hasOwn(held, key)) continue;
-    const encoded = encodeInfinity(field, held[key]);
-    if (encoded !== held[key]) (out ??= { ...held })[key] = encoded;
-  }
-  return out ?? value;
-};
-function createPrefsStore(schema, cache, validators, onClose, version = 0) {
-  const leaves = new Map([...prefLeaves(schema)].filter(([, leaf]) => prefHoldsValue(leaf)));
-  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();
-  let storedTree = null;
-  const buildStored = () => {
-    const tree = {};
-    const branches = new WeakSet([tree]);
-    for (const [name, record] of cache.entries()) {
-      if (name === VERSION_RECORD) continue;
-      const value = recordValue(record);
-      const parts = name.split(".");
-      let cursor = tree;
-      for (const part of parts.slice(0, -1)) {
-        const next = cursor[part];
-        if (typeof next === "object" && next !== null && branches.has(next)) {
-          cursor = next;
-        } else {
-          const branch = {};
-          branches.add(branch);
-          setOwnPrefValue(cursor, part, branch);
-          cursor = branch;
-        }
-      }
-      const last = parts[parts.length - 1];
-      if (!branches.has(cursor[last])) setOwnPrefValue(cursor, last, value);
-    }
-    return tree;
-  };
-  const listeners = /* @__PURE__ */ new Set();
-  const stopCache = cache.subscribe((changes) => {
-    const records = changes.filter((c) => c.name !== VERSION_RECORD);
-    if (records.length === 0) return;
-    storedTree = null;
-    const mine = records.filter((c) => leaves.has(c.name));
-    if (mine.length > 0) snapshot = null;
-    const now = current();
-    const out = mine.map((c) => ({ path: c.name, value: now.byPath.get(c.name), origin: c.origin }));
-    for (const listener of [...listeners]) listener(out);
-  });
-  return {
-    schema,
-    get: (path) => current().byPath.get(path),
-    set: (path, value) => {
-      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));
-    },
-    reset: (path) => {
-      for (const p of leaves.keys()) {
-        if (path === void 0 || p === path || p.startsWith(`${path}.`)) cache.delete(p);
-      }
-    },
-    isSet: (path) => cache.has(path),
-    values: () => current().tree,
-    unset: () => current().unset,
-    stored: () => storedTree ??= buildStored(),
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    get writable() {
-      return cache.writable;
-    },
-    read: () => cache.read(),
-    whenRead: () => cache.whenRead(),
-    flush: () => cache.flush(),
-    close: async () => {
-      onClose?.();
-      stopCache();
-      listeners.clear();
-      await cache.close();
-    }
-  };
-}
-
-// src/open.ts
-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 runs;
 }
-function openPrefsSync(schema, options) {
-  const cache = openRecordsSync({ storage: options.storage, prefix: options.prefix });
-  const stop = watch(cache, options);
-  if (runPrefsMigrations(cache, options.migrations ?? [])) void cache.flush();
-  return createPrefsStore(schema, cache, options.validators, stop, options.migrations?.length ?? 0);
-}
-var watch = (cache, options) => watchPrefsVersion(cache, options.migrations ?? []);
 
 // src/kinds.ts
 var ONE = { compound: false, several: false };
@@ -569,69 +317,7 @@ function prefIsCompound(leaf) {
 function prefDrawsSeveral(leaf) {
   return traitsOf(leaf).several;
 }
-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 scale = opts?.precision === void 0 ? void 0 : 10 ** opts.precision;
-  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 };
-  }
-  const toDisplay = (stored) => {
-    const shown = (stored - self.offset) / self.factor;
-    return scale === void 0 ? shown : Math.round(shown * scale) / scale;
-  };
-  return {
-    toDisplay,
-    fromDisplay: (shown) => shown * self.factor + self.offset,
-    suffix,
-    accepts,
-    format: (stored) => `${formatUnit(stored, display, system, {
-      precision: opts?.precision ?? 2,
-      suffix: false
-    })}${suffix}`
-  };
-}
-var PREF_KINDS = {
-  number: true,
-  boolean: true,
-  string: true,
-  enum: true,
-  color: true,
-  paint: true,
-  object: true,
-  list: true,
-  map: true,
-  union: true,
-  field: true,
-  action: true,
-  alias: true,
-  label: true,
-  separator: true
-};
-function pairRowsOf(leaves) {
-  const rows = /* @__PURE__ */ new Map();
-  for (const [path, leaf] of leaves) {
-    if (!leaf.pair || rows.has(path)) continue;
-    const row = { key: path, label: leaf.pair.label ?? leaf.name };
-    rows.set(path, row);
-    const partners = typeof leaf.pair.with === "string" ? [leaf.pair.with] : leaf.pair.with;
-    for (const partner of partners) if (!rows.has(partner)) rows.set(partner, row);
-  }
-  return rows;
-}
-function isBuiltinPref(leaf) {
-  return Object.hasOwn(PREF_KINDS, leaf.kind);
-}
 
-export { PREF_KINDS, PREF_KIND_TRAITS, VERSION_RECORD, filterPrefSubtree, flattenPrefValues, isBuiltinPref, isPrefLeaf, isPrefSection, openPrefs, openPrefsSync, pairRowsOf, prefAliasTarget, prefAliasedLeaf, prefDisplayBounds, prefDrawsSeveral, prefGroupIsPage, prefHoldsValue, prefIsCompound, prefLeafAt, prefLeaves, prefObjectBase, prefObjectWithField, prefSectionLeaves, prefType, prefUnit, prefValueAtPath, prefVariantDefault, prefVariantOf, repairPrefValue, visiblePrefSubtree };
+export { PREF_ENTRY, PREF_KIND_TRAITS, PREF_SCOPE, applyPrefConditions, applyPrefEntryConditions, pairRuns, prefAliasTargets, prefDrawsSeveral, prefGroupIsPage, prefIsCompound, prefJudge, prefObjectBase, prefObjectWithField, prefReader, prefScopeAt, prefScopeUnder, prefShownReader, prefShownValue, prefTabRuns, prefType };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map