@weasel-js/prefs 1.9.3 → 1.10.0

package/dist/index.js

@@ -1,378 +1,323 @@
-import { openRecords, openRecordsSync } from '@weasel-js/storage';
-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/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;
-}
-function prefValueAtPath(values, path) {
-  let cur = values;
-  for (const seg of path.split(".")) {
-    if (cur == null || typeof cur !== "object") return void 0;
-    cur = cur[seg];
+// 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 cur;
+  return out;
 }
-function visiblePrefSubtree(node, showHidden) {
-  if (isPrefLeaf(node)) return node.hidden && !showHidden ? null : node;
-  const group = node;
-  const children = {};
-  for (const [key, child] of Object.entries(group.children)) {
-    const kept = visiblePrefSubtree(child, showHidden);
-    if (kept) children[key] = kept;
-  }
-  if (Object.keys(children).length === 0) return null;
-  return { ...node, children };
+
+// 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;
 }
-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);
-    }
+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);
   };
-  walk(schema, "");
-  return out;
 }
-function assignPrefValueAtPath(root, path, value) {
-  const parts = path.split(".");
-  let cursor = root;
-  for (let i = 0; i < parts.length - 1; i++) {
-    cursor = cursor[parts[i]] ??= {};
-  }
-  cursor[parts[parts.length - 1]] = value;
+
+// 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 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 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 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 deferEntryConditions(holds) {
+  return (condition, field) => prefConditionReadsItem(condition) || holds(condition, field);
 }
-function filterPrefSubtree(node, query, path = "") {
-  const q = query.trim().toLowerCase();
-  if (q === "") return node;
-  if (isPrefLeaf(node)) return prefLeafMatches(node, 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}`);
-    if (kept) children[key] = kept;
-  }
-  if (Object.keys(children).length === 0) return null;
-  return { ...node, children };
+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;
+  };
 }
 
-// src/migrate.ts
-var isVersion = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
-function runPrefsMigrations(cache, migrations) {
-  const target = migrations.length;
-  const raw = cache.get(VERSION_RECORD);
-  if (cache.has(VERSION_RECORD) && !isVersion(raw)) {
-    console.warn(
-      `[prefs] "${cache.prefix}" has an unreadable ${VERSION_RECORD} (${JSON.stringify(raw)}); opening read-only`
-    );
-    cache.stopWriting();
-    return false;
+// 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);
   }
-  const stored = cache.has(VERSION_RECORD) ? raw : 0;
-  if (stored > target) {
-    console.warn(
-      `[prefs] "${cache.prefix}" was written at version ${stored}, newer than this build's ${target}; opening read-only`
-    );
-    cache.stopWriting();
-    return false;
+  return void 0;
+}
+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);
   }
-  if (stored === target || !cache.writable) return false;
-  const before = cache.entries().filter(([name]) => name !== VERSION_RECORD);
-  const records = new Map(before.map(([name, value]) => [name, structuredClone(value)]));
-  for (let v = stored; v < target; v++) {
-    try {
-      migrations[v](records);
-    } 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;
-    }
+  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;
   }
-  for (const [name] of before) if (!records.has(name)) cache.delete(name);
-  for (const [name, value] of records) {
-    if (value === void 0) cache.delete(name);
-    else cache.set(name, value);
+  return scope;
+}
+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;
   }
-  cache.set(VERSION_RECORD, target);
-  return true;
+  return scope;
 }
-function watchPrefsVersion(cache, target) {
-  return cache.subscribe((changes) => {
-    for (const change of changes) {
-      if (change.origin !== "remote" || change.name !== VERSION_RECORD || change.value === void 0) continue;
-      if (!isVersion(change.value)) {
-        console.warn(
-          `[prefs] "${cache.prefix}" has an unreadable ${VERSION_RECORD} (${JSON.stringify(change.value)}) from another writer; no longer persisting`
-        );
-        cache.stopWriting();
-      } else if (change.value > target) {
-        console.warn(
-          `[prefs] "${cache.prefix}" was migrated to version ${change.value} by another writer; this build knows ${target}; no longer persisting`
-        );
-        cache.stopWriting();
-      }
-    }
-  });
+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 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;
 }
 
-// src/repair.ts
-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;
+// 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 };
     }
-  }
-  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;
+    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 };
     }
-    case "object":
-      if (leaf.fromScalar || isPlainObject(stored)) return stored;
-      return leaf.default;
-    default:
-      return stored;
-  }
+    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 isPlainObject(v) {
-  return v !== null && typeof v === "object" && !Array.isArray(v);
+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 };
 }
-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;
+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 };
 }
 
-// src/store.ts
-var encodeInfinity = (leaf, value) => leaf.kind === "number" && (value === Infinity || value === -Infinity) ? String(value) : value;
-function createPrefsStore(schema, cache, validators, onClose) {
-  const leaves = prefLeaves(schema);
-  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 stored = cache.get(path);
-        raw.set(path, stored);
-        value = previous?.raw.has(path) && previous.raw.get(path) === stored ? 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, value] of cache.entries()) {
-      if (name === VERSION_RECORD) continue;
-      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);
-          cursor[part] = branch;
-          cursor = branch;
-        }
-      }
-      const last = parts[parts.length - 1];
-      if (!branches.has(cursor[last])) cursor[last] = value;
-    }
-    return tree;
+// 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);
   };
-  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;
-      }
-      cache.set(path, encodeInfinity(leaf, value));
+    holds,
+    leafAt,
+    shown: (alias) => {
+      const target = prefAliasTarget(alias, leafAt);
+      return target && { path: target.path, leaf: prefAliasedLeaf(alias, target.leaf) };
     },
-    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;
-    },
-    flush: () => cache.flush(),
-    close: async () => {
-      onClose?.();
-      stopCache();
-      listeners.clear();
-      await cache.close();
-    }
+    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/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);
+// src/object.ts
+var isObject = (v) => typeof v === "object" && v !== null;
+function prefObjectBase(pref, held) {
+  if (isObject(held)) return held;
+  return pref.fromScalar?.(held) ?? (isObject(pref.default) ? pref.default : {});
 }
-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);
+function prefObjectWithField(pref, held, key, value) {
+  const base = prefObjectBase(pref, held);
+  if (value !== void 0) return { ...base, [key]: value };
+  const { [key]: _dropped, ...rest } = base;
+  return rest;
 }
-var watch = (cache, options) => cache.writable ? watchPrefsVersion(cache, (options.migrations ?? []).length) : void 0;
-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 };
+
+// src/type.ts
+function prefType(name, leaf) {
+  return { ...leaf, type: name };
+}
+
+// src/groups.ts
+function prefGroupIsPage(group) {
+  return group.as === void 0 || group.as === "page";
+}
+
+// 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 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}`
-  };
+  return runs;
 }
-var PREF_KINDS = {
-  number: true,
-  boolean: true,
-  string: true,
-  enum: true,
-  color: true,
-  paint: true,
-  object: true,
-  field: true
+
+// src/kinds.ts
+var ONE = { compound: false, several: false };
+var MANY = { compound: true, several: true };
+var PREF_KIND_TRAITS = {
+  number: ONE,
+  boolean: ONE,
+  string: ONE,
+  enum: ONE,
+  color: ONE,
+  paint: ONE,
+  object: MANY,
+  list: MANY,
+  map: MANY,
+  union: MANY,
+  field: ONE,
+  action: { compound: false, several: true },
+  alias: ONE,
+  label: ONE,
+  separator: ONE
 };
-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;
+var traitsOf = (leaf) => Object.hasOwn(PREF_KIND_TRAITS, leaf.kind) ? PREF_KIND_TRAITS[leaf.kind] : ONE;
+function prefIsCompound(leaf) {
+  return traitsOf(leaf).compound;
 }
-function isBuiltinPref(leaf) {
-  return Object.hasOwn(PREF_KINDS, leaf.kind);
+function prefDrawsSeveral(leaf) {
+  return traitsOf(leaf).several;
 }
 
-export { PREF_KINDS, VERSION_RECORD, filterPrefSubtree, flattenPrefValues, isBuiltinPref, isPrefLeaf, openPrefs, openPrefsSync, pairRowsOf, prefDisplayBounds, prefLeaves, prefUnit, prefValueAtPath, 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