@weasel-js/prefs 1.9.4 → 1.10.1

package/dist/chunk-ASSX3JHY.js

@@ -0,0 +1,1180 @@
+import { formatUnit, unitScale } from '@weasel-js/quantity';
+import { isPlainObject, createEmitter } from '@weasel-js/registry';
+import { hexToRgba, interpolateSrgb, rgbaToHex } from '@weasel-js/paint';
+import { openRecords, openRecordsSync } from '@weasel-js/storage';
+
+// src/alias.ts
+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";
+function formOf(value) {
+  if (!isPlainObject(value)) return void 0;
+  const keys = Object.keys(value);
+  if (keys.length === 1 && (keys[0] === "all" || keys[0] === "any")) return Array.isArray(value[keys[0]]) ? keys[0] : void 0;
+  if (keys.length === 1 && keys[0] === "not") return "not";
+  if (typeof value.path !== "string" || !keys.every((key) => TEST_KEYS.has(key))) return void 0;
+  if (value.from !== void 0 && value.from !== "item") return void 0;
+  if (value.is !== void 0 && !isValue(value.is)) return void 0;
+  if (value.isNot !== void 0 && !isValue(value.isNot)) return void 0;
+  if (value.in !== void 0 && !(Array.isArray(value.in) && value.in.every(isValue))) return void 0;
+  return ORDERINGS.every((op) => value[op] === void 0 || typeof value[op] === "number") ? "test" : void 0;
+}
+function partsOf(condition, form) {
+  const held = condition;
+  return form === "test" ? [] : form === "not" ? [held.not] : held[form];
+}
+function isPrefCondition(value) {
+  const form = formOf(value);
+  return form !== void 0 && partsOf(value, form).every(isPrefCondition);
+}
+var same = (held, value) => value === null ? held == null : held === value;
+function isSet(held) {
+  if (Array.isArray(held)) return held.length > 0;
+  if (isPlainObject(held)) return Object.keys(held).length > 0;
+  return Boolean(held);
+}
+function testHolds(test, held) {
+  const ops = Object.keys(test).filter((key) => key !== "path" && key !== "from" && test[key] !== void 0);
+  if (ops.length === 0) return isSet(held);
+  if (test.is !== void 0 && !same(held, test.is)) return false;
+  if (test.isNot !== void 0 && same(held, test.isNot)) return false;
+  if (test.in !== void 0 && !test.in.some((value) => same(held, value))) return false;
+  if (!ORDERINGS.some((op) => test[op] !== void 0)) return true;
+  if (typeof held !== "number") return false;
+  return (test.above === void 0 || held > test.above) && (test.below === void 0 || held < test.below) && (test.atLeast === void 0 || held >= test.atLeast) && (test.atMost === void 0 || held <= test.atMost);
+}
+function prefConditionHolds(condition, read) {
+  if ("all" in condition) return condition.all.every((part) => prefConditionHolds(part, read));
+  if ("any" in condition) return condition.any.some((part) => prefConditionHolds(part, read));
+  if ("not" in condition) return !prefConditionHolds(condition.not, read);
+  return testHolds(condition, read(condition.path, condition.from));
+}
+function prefIsShown(node, read) {
+  return node.showIf === void 0 || prefConditionHolds(node.showIf, read);
+}
+function prefIsEnabled(node, read) {
+  return node.enableIf === void 0 || prefConditionHolds(node.enableIf, read);
+}
+function prefConditionPaths(condition, from) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (c) => {
+    if ("all" in c) c.all.forEach(walk);
+    else if ("any" in c) c.any.forEach(walk);
+    else if ("not" in c) walk(c.not);
+    else if (c.from === from) out.add(c.path);
+  };
+  walk(condition);
+  return [...out];
+}
+function prefConditionReadsItem(condition) {
+  if ("all" in condition) return condition.all.some(prefConditionReadsItem);
+  if ("any" in condition) return condition.any.some(prefConditionReadsItem);
+  if ("not" in condition) return prefConditionReadsItem(condition.not);
+  return condition.from === "item";
+}
+function mapPrefConditionPaths(condition, move) {
+  const each = (parts) => {
+    const next = parts.map((part) => mapPrefConditionPaths(part, move));
+    return next.every((part, i) => part === parts[i]) ? parts : next;
+  };
+  if ("all" in condition) {
+    const all = each(condition.all);
+    return all === condition.all ? condition : { all };
+  }
+  if ("any" in condition) {
+    const any = each(condition.any);
+    return any === condition.any ? condition : { any };
+  }
+  if ("not" in condition) {
+    const not = mapPrefConditionPaths(condition.not, move);
+    return not === condition.not ? condition : { not };
+  }
+  const path = move(condition.path, condition.from);
+  return path === condition.path ? condition : { ...condition, path };
+}
+
+// src/schema.ts
+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);
+}
+
+// src/holding.ts
+var UNSEEN = /* @__PURE__ */ Symbol("unseen");
+var under = (at, key) => at === "" ? key : `${at}.${key}`;
+function amongFields(fields, path, at) {
+  const exact = fields.find(([key]) => key === path);
+  if (exact) return { leaf: exact[1], ...at === void 0 ? {} : { within: at } };
+  const outer = fields.find(([key]) => path.startsWith(`${key}.`));
+  return outer && insideLeaf(outer[1], path.slice(outer[0].length + 1), under(at ?? "", outer[0]));
+}
+function insideLeaf(leaf, rest, at) {
+  if (leaf.kind === "object") return amongFields(prefSectionLeaves(leaf.children), rest, at);
+  if (leaf.kind === "union") {
+    const { tag, variants } = leaf;
+    if (rest === tag) {
+      const options = Object.keys(variants).map((value) => ({ value, label: variants[value].name }));
+      return { leaf: { kind: "enum", name: tag, description: "", default: void 0, options }, within: at };
+    }
+    for (const variant of Object.values(variants)) {
+      const found = amongFields(prefSectionLeaves(variant.children), rest, at);
+      if (found !== void 0) return found;
+    }
+    return void 0;
+  }
+  return !isBuiltinPref(leaf) || leaf.kind === "list" || leaf.kind === "map" || leaf.kind === "paint" ? UNSEEN : void 0;
+}
+function prefLeafHolding(schema, path) {
+  if (isPrefSection(schema)) return amongFields(prefSectionLeaves(schema.members), path, void 0);
+  const steps = path.split(".");
+  let node = schema;
+  for (let i = 0; i < steps.length; i++) {
+    if (isPrefLeaf(node)) return insideLeaf(node, steps.slice(i).join("."), steps.slice(0, i).join("."));
+    if (!Object.hasOwn(node.children, steps[i])) return void 0;
+    node = node.children[steps[i]];
+  }
+  return isPrefLeaf(node) ? { leaf: node } : void 0;
+}
+function prefSchemaHolding(schema, path, over) {
+  return over === void 0 || prefLeafHolding(schema, path) !== void 0 ? schema : over;
+}
+function prefLeafHoldingIn(item, path) {
+  return path === "" ? { leaf: item } : insideLeaf(item, path, "");
+}
+
+// src/conditionCheck.ts
+var show = (value) => typeof value === "string" ? `'${value}'` : String(value);
+function neverHolds(leaf, value) {
+  if (value === null || !isBuiltinPref(leaf)) return void 0;
+  switch (leaf.kind) {
+    case "number":
+      return typeof value === "number" ? void 0 : "it is a number";
+    case "boolean":
+      return typeof value === "boolean" ? void 0 : "it is a boolean";
+    case "string":
+    case "color":
+    case "field":
+      return typeof value === "string" ? void 0 : `it is a ${leaf.kind === "string" ? "string" : `${leaf.kind}, held as a string`}`;
+    case "enum": {
+      const { options } = leaf;
+      if (options.some((option) => option.value === value)) return void 0;
+      return `its options are ${options.map((option) => show(option.value)).join(", ")}`;
+    }
+    case "object":
+      return leaf.fromScalar ? void 0 : "it is an object";
+    default:
+      return `it is a ${leaf.kind}`;
+  }
+}
+function testProblems(test, schema, site, over) {
+  const { path } = test;
+  if (test.from === "item" && site.within === void 0) {
+    return [{ code: "no-item", path, problem: `"${path}" is read from an entry, and this is inside no list or map` }];
+  }
+  const found = leafProblems(test, schema, site, over);
+  if (test.in?.length !== 0) return found;
+  return [...found, { code: "never", path, problem: `"${path}" is one of nothing, which never holds` }];
+}
+function leafProblems(test, schema, site, over) {
+  const { path } = test;
+  const inEntry = test.from === "item";
+  const held = inEntry ? prefLeafHoldingIn(site.within.item, path) : prefLeafHolding(prefSchemaHolding(schema, path, over), path);
+  if (held === void 0) return [{ code: "no-leaf", path, problem: `no leaf holds a value at "${path}"${inEntry ? " in the entry" : ""}` }];
+  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` }];
+  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}` });
+  }
+  const ordering = ORDERINGS.find((op) => test[op] !== void 0);
+  if (ordering !== void 0 && isBuiltinPref(leaf) && leaf.kind !== "number") {
+    out.push({ code: "value", path, problem: `${named} is a${leaf.kind === "object" || leaf.kind === "enum" ? "n" : ""} ${leaf.kind}, and "${ordering}" compares numbers` });
+  }
+  return out;
+}
+function checkPrefCondition(condition, schema, site = {}, over) {
+  if (site.itemShowIf && site.within) {
+    const { kind } = site.within;
+    const problem = `a ${kind}'s item is drawn with each entry and is never hidden: put the condition on the entry's fields, or on the ${kind}`;
+    return [{ code: "item-show", problem }, ...checkPrefCondition(condition, schema, { within: site.within }, over)];
+  }
+  const form = formOf(condition);
+  if (form === void 0) {
+    const shown = typeof condition === "function" ? "a function" : JSON.stringify(condition);
+    return [{ code: "malformed", problem: `not a condition: ${shown}` }];
+  }
+  if (form === "test") return testProblems(condition, schema, site, over);
+  return partsOf(condition, form).flatMap((part) => checkPrefCondition(part, schema, site, over));
+}
+function checkPrefConditions(schema, over) {
+  const out = [];
+  const own = (node, at, within, isItem = false) => {
+    for (const field of ["showIf", "enableIf"]) {
+      if (node[field] === void 0) continue;
+      const site = { ...within ? { within } : {}, ...isItem && field === "showIf" ? { itemShowIf: true } : {} };
+      for (const problem of checkPrefCondition(node[field], schema, site, over)) out.push({ ...problem, at, field });
+    }
+  };
+  const under2 = (at, key) => at === "" ? key : `${at}.${key}`;
+  const leaf = (node, at, within, isItem = false) => {
+    own(node, at, within, isItem);
+    if (node.kind === "object") members(node.children, at, true, within);
+    else if (node.kind === "list" || node.kind === "map") {
+      const holder = node;
+      if (holder.item !== void 0) leaf(holder.item, under2(at, "item"), holder, true);
+    } else if (node.kind === "union") {
+      for (const [key, variant] of Object.entries(node.variants)) leaf(variant, under2(at, key), within);
+    }
+  };
+  const members = (held, at, nested, within) => {
+    for (const [key, child] of Object.entries(held)) {
+      const here = nested ? under2(at, key) : key;
+      if (isPrefLeaf(child)) leaf(child, here, within);
+      else {
+        own(child, here, within);
+        members(child.members, nested ? at : "", nested, within);
+      }
+    }
+  };
+  const group = (node, at) => {
+    own(node, at, void 0);
+    for (const [key, child] of Object.entries(node.children)) {
+      if (isPrefLeaf(child)) leaf(child, under2(at, key), void 0);
+      else group(child, under2(at, key));
+    }
+  };
+  if (isPrefSection(schema)) {
+    own(schema, "", void 0);
+    members(schema.members, "", false, void 0);
+  } else group(schema, "");
+  return out;
+}
+function isPrefLocus(value) {
+  if (!isPlainObject(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 2 && typeof value.$by === "string" && isPlainObject(value.$of);
+}
+function selectionWeights(selection) {
+  return Object.fromEntries(Object.entries(selection).map(([path, option]) => [path, { [option]: 1 }]));
+}
+var member = (locus, option, absent) => Object.hasOwn(locus.$of, option) ? locus.$of[option] : absent;
+function weighLocus(stored, weights, absent) {
+  const out = [];
+  const walk = (value, weight) => {
+    if (!isPrefLocus(value)) {
+      out.push({ value, weight });
+      return;
+    }
+    for (const [option, share] of Object.entries(weights[value.$by] ?? {})) {
+      if (share > 0) walk(member(value, option, absent), weight * share);
+    }
+  };
+  walk(stored, 1);
+  return out;
+}
+function memberAt(stored, selection, absent) {
+  let value = stored;
+  while (isPrefLocus(value)) {
+    const option = selection[value.$by];
+    if (option === void 0) return absent;
+    value = member(value, option, absent);
+  }
+  return value;
+}
+function writeMember(stored, selection, next) {
+  if (!isPrefLocus(stored)) return next;
+  const option = selection[stored.$by];
+  if (option === void 0) return stored;
+  return { $by: stored.$by, $of: { ...stored.$of, [option]: writeMember(stored.$of[option], selection, next) } };
+}
+function splitLocus(stored, by, options, order) {
+  const across = (value) => ({ $by: by, $of: Object.fromEntries(options.map((option) => [option, value])) });
+  if (!isPrefLocus(stored)) return across(stored);
+  if (stored.$by === by) return stored;
+  if (order.indexOf(stored.$by) > order.indexOf(by)) return across(stored);
+  return mapMembers(stored, (inner) => splitLocus(inner, by, options, order));
+}
+function joinLocus(stored, by, selection, absent) {
+  if (!isPrefLocus(stored)) return stored;
+  if (stored.$by !== by) return mapMembers(stored, (inner) => joinLocus(inner, by, selection, absent));
+  const option = selection[by];
+  return option === void 0 ? absent : member(stored, option, absent);
+}
+function mapMembers(locus, fn) {
+  let out;
+  for (const [option, value] of Object.entries(locus.$of)) {
+    const next = fn(value);
+    if (next !== value) (out ??= { ...locus.$of })[option] = next;
+  }
+  return out ? { $by: locus.$by, $of: out } : locus;
+}
+function mapLocusMembers(stored, fn) {
+  return isPrefLocus(stored) ? mapMembers(stored, (inner) => mapLocusMembers(inner, fn)) : fn(stored);
+}
+function locusSelectors(stored) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (!isPrefLocus(value)) return;
+    out.add(value.$by);
+    for (const inner of Object.values(value.$of)) walk(inner);
+  };
+  walk(stored);
+  return out;
+}
+function repairLocus(stored, allowed, optionsOf, repairMember) {
+  const BAD = /* @__PURE__ */ Symbol("bad");
+  const walk = (value, met) => {
+    if (!isPrefLocus(value)) return repairMember(value);
+    const options = allowed.includes(value.$by) && !met.includes(value.$by) ? optionsOf(value.$by) : void 0;
+    if (!options) return BAD;
+    const of = {};
+    for (const option of options) {
+      if (!Object.hasOwn(value.$of, option)) continue;
+      const read2 = walk(value.$of[option], [...met, value.$by]);
+      if (read2 === BAD) return BAD;
+      of[option] = read2;
+    }
+    return { $by: value.$by, $of: of };
+  };
+  const read = walk(stored, []);
+  return read === BAD ? void 0 : read;
+}
+var heaviest = (members) => members.reduce((most, m) => m.weight > most.weight ? m : most).value;
+var blendNumber = (members, leaf) => {
+  let sum = 0;
+  let total = 0;
+  for (const { value, weight } of members) {
+    if (typeof value !== "number" || !Number.isFinite(value)) return heaviest(members);
+    sum += value * weight;
+    total += weight;
+  }
+  return sum / total;
+};
+var blendColor = (members, leaf) => {
+  let mixed;
+  let total = 0;
+  for (const { value, weight } of members) {
+    let next;
+    try {
+      next = hexToRgba(value);
+    } catch {
+      return heaviest(members);
+    }
+    total += weight;
+    if (!mixed) {
+      mixed = next;
+      continue;
+    }
+    const t = weight / total;
+    const [r, g, b] = interpolateSrgb([mixed[0], mixed[1], mixed[2]], [next[0], next[1], next[2]], t, "oklch");
+    mixed = [r, g, b, mixed[3] + (next[3] - mixed[3]) * t];
+  }
+  return rgbaToHex(mixed);
+};
+var PREF_BLENDS = { number: blendNumber, color: blendColor };
+function blendPref(leaf, members, blends) {
+  if (members.length === 0) return leaf.default;
+  if (members.length === 1) return members[0].value;
+  const blend = (blends && Object.hasOwn(blends, leaf.kind) ? blends[leaf.kind] : void 0) ?? (Object.hasOwn(PREF_BLENDS, leaf.kind) ? PREF_BLENDS[leaf.kind] : void 0) ?? heaviest;
+  return blend(members, leaf);
+}
+
+// src/splitCheck.ts
+var refusal = (leaf) => {
+  if (!leaf) return ["no-leaf", "names no leaf"];
+  if (leaf.kind !== "enum") return ["not-enum", `names a ${leaf.kind} leaf, and only an enum has options to split by`];
+  const selector = leaf;
+  if (selector.encoding) return ["encoded", "names an enum with an encoding, whose stored value is not its option"];
+  if (selector.clearable) return ["clearable", "names a clearable enum, which may hold none of its options"];
+  if (selector.splitBy?.length) return ["split", "names a leaf that may itself be split"];
+  return void 0;
+};
+function prefSelectors(leaves) {
+  const out = /* @__PURE__ */ new Map();
+  for (const leaf of leaves.values()) {
+    for (const path of leaf.splitBy ?? []) {
+      const selector = leaves.get(path);
+      if (out.has(path) || refusal(selector)) continue;
+      out.set(path, selector.options.map((option) => option.value));
+    }
+  }
+  return out;
+}
+function checkPrefSplits(schema) {
+  const leaves = prefLeaves(schema);
+  const out = [];
+  for (const [at, leaf] of leaves) {
+    for (const path of locusSelectors(leaf.defaultLocus)) {
+      if (leaf.splitBy?.includes(path)) continue;
+      out.push({ code: "default", at, path, problem: `its defaultLocus is split by "${path}", which its splitBy does not list` });
+    }
+    if (!leaf.splitBy?.length) continue;
+    if (!prefHoldsValue(leaf)) {
+      out.push({ code: "valueless", at, problem: `a ${leaf.kind} leaf holds no value to split` });
+      continue;
+    }
+    leaf.splitBy.forEach((path, i) => {
+      if (leaf.splitBy.indexOf(path) !== i) {
+        out.push({ code: "twice", at, path, problem: `"${path}" is listed twice` });
+        return;
+      }
+      const why = refusal(leaves.get(path));
+      if (why) out.push({ code: why[0], at, path, problem: `"${path}" ${why[1]}` });
+    });
+  }
+  return out;
+}
+
+// src/union.ts
+function prefVariantOf(leaf, value) {
+  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;
+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;
+  }
+  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();
+  };
+}
+
+// src/snapshot.ts
+function readStored(source, leaf, stored) {
+  const repair = (value) => repairPrefValue(leaf, value, source.validators);
+  if (!leaf.splitBy?.length || !isPrefLocus(stored)) return repair(stored);
+  const read = repairLocus(stored, leaf.splitBy, (path) => source.selectors.get(path), repair);
+  return read === void 0 ? leaf.default : read;
+}
+function resolveHeld(source, leaf, held, weights) {
+  return isPrefLocus(held) ? blendPref(leaf, weighLocus(held, weights, leaf.default), source.blends) : held;
+}
+function createSnapshots(source) {
+  const { leaves, cache, selectors } = source;
+  let snapshot = null;
+  let previous = null;
+  const unsetLoci = /* @__PURE__ */ new Map();
+  const unsetHeld = (path, leaf) => {
+    if (leaf.defaultLocus === void 0) return leaf.default;
+    if (!unsetLoci.has(path)) unsetLoci.set(path, readStored(source, leaf, leaf.defaultLocus));
+    return unsetLoci.get(path);
+  };
+  const build = () => {
+    const held = /* @__PURE__ */ new Map();
+    const raw = /* @__PURE__ */ new Map();
+    const unset = /* @__PURE__ */ new Set();
+    for (const [path, leaf] of leaves) {
+      if (!cache.has(path)) {
+        held.set(path, unsetHeld(path, leaf));
+        unset.add(path);
+        continue;
+      }
+      const record = cache.get(path);
+      raw.set(path, record);
+      const same2 = previous?.raw.has(path) && previous.raw.get(path) === record;
+      held.set(path, same2 ? previous.held.get(path) : readStored(source, leaf, recordValue(record)));
+    }
+    previous = { raw, held };
+    const selection = {};
+    for (const path of selectors.keys()) selection[path] = held.get(path);
+    const weights = selectionWeights(selection);
+    const byPath = /* @__PURE__ */ new Map();
+    const splitBy = /* @__PURE__ */ new Map();
+    const loci = /* @__PURE__ */ new Map();
+    const tree = {};
+    for (const [path, leaf] of leaves) {
+      const value = held.get(path);
+      if (isPrefLocus(value)) loci.set(path, value);
+      for (const selector of locusSelectors(value)) splitBy.set(selector, [...splitBy.get(selector) ?? [], path]);
+      const read = resolveHeld(source, leaf, value, weights);
+      byPath.set(path, read);
+      assignPrefValueAtPath(tree, path, read);
+    }
+    return { byPath, held, loci, selection, splitBy, tree, unset };
+  };
+  return {
+    current: () => snapshot ??= build(),
+    peek: () => snapshot,
+    drop: () => {
+      snapshot = null;
+    }
+  };
+}
+function weightsUnder(selectors, selection, given) {
+  const out = {};
+  for (const [path, options] of selectors) {
+    const own = Object.hasOwn(given, path) ? given[path] : void 0;
+    out[path] = own ? Object.fromEntries(options.filter((option) => (own[option] ?? 0) > 0).map((option) => [option, own[option]])) : { [selection[path]]: 1 };
+  }
+  return out;
+}
+function selectionAt(selectors, selection, at) {
+  const out = { ...selection };
+  for (const [path, option] of Object.entries(at)) {
+    if (selectors.get(path)?.includes(option)) out[path] = option;
+  }
+  return out;
+}
+
+// src/storeWrites.ts
+var encodeInfinity = (leaf, value) => {
+  if (leaf.kind === "number") return value === Infinity || value === -Infinity ? String(value) : value;
+  if (leaf.kind === "list" && Array.isArray(value)) {
+    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 prefWrites({ leaves, cache, selectors, version, selection, warnIfClosed }) {
+  const unsetLocus = (leaf) => {
+    if (leaf.defaultLocus === void 0 || !leaf.splitBy?.length) return void 0;
+    return repairLocus(leaf.defaultLocus, leaf.splitBy, (by) => selectors.get(by), (member2) => encodeInfinity(leaf, member2));
+  };
+  const rawAt = (path, leaf) => cache.has(path) ? recordValue(cache.get(path)) : unsetLocus(leaf) ?? encodeInfinity(leaf, leaf.default);
+  const store = (path, stored) => {
+    cache.set(path, stored === void 0 ? void 0 : stampRecord(stored, version));
+  };
+  const splitOf = (path, by) => {
+    warnIfClosed(path);
+    const leaf = leaves.get(path);
+    const options = selectors.get(by);
+    if (leaf?.splitBy?.includes(by) && options) return { leaf, options };
+    console.warn(`[prefs] "${path}" cannot be split by "${by}"; ignoring`);
+    return void 0;
+  };
+  const set = (path, value, write) => {
+    warnIfClosed(path);
+    const leaf = leaves.get(path);
+    if (!leaf) {
+      console.warn(`[prefs] no leaf at "${path}"; ignoring the write`);
+      return;
+    }
+    if (leaf.splitBy?.length && isPrefLocus(value)) {
+      store(path, mapLocusMembers(value, (member2) => encodeInfinity(leaf, member2)));
+      return;
+    }
+    const stored = encodeInfinity(leaf, value);
+    const had = cache.has(path) ? recordValue(cache.get(path)) : unsetLocus(leaf);
+    const intoMember = stored !== void 0 && leaf.splitBy?.length && isPrefLocus(had);
+    const under2 = write?.at ? selectionAt(selectors, selection(), write.at) : selection();
+    store(path, intoMember ? writeMember(had, under2, stored) : stored);
+  };
+  const split = (path, by) => {
+    const found = splitOf(path, by);
+    if (!found) return;
+    const had = rawAt(path, found.leaf);
+    const next = splitLocus(had, by, found.options, found.leaf.splitBy);
+    if (next !== had) store(path, next);
+  };
+  const join = (path, by) => {
+    const found = splitOf(path, by);
+    if (!found) return;
+    const had = rawAt(path, found.leaf);
+    const next = joinLocus(had, by, selection(), encodeInfinity(found.leaf, found.leaf.default));
+    if (next !== had) store(path, next);
+  };
+  return { set, split, join };
+}
+
+// src/store.ts
+function storedRecords(cache) {
+  const tree = {};
+  const branches = new WeakSet([tree]);
+  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;
+}
+function createPrefsStore(schema, cache, validators, onClose, version = 0, blends) {
+  const leaves = new Map([...prefLeaves(schema)].filter(([, leaf]) => prefHoldsValue(leaf)));
+  for (const { field, at, problem } of checkPrefConditions(schema)) {
+    console.warn(`[prefs] ${field} of ${at === "" ? "the schema" : `"${at}"`}: ${problem}`);
+  }
+  for (const { at, problem } of checkPrefSplits(schema)) console.warn(`[prefs] splitBy of "${at}": ${problem}`);
+  const source = { leaves, cache, selectors: prefSelectors(leaves), validators, blends };
+  const { current, peek, drop } = createSnapshots(source);
+  let storedTree = null;
+  let changed = createEmitter();
+  const stopCache = cache.subscribe((changes) => {
+    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));
+    const before = peek();
+    if (mine.length > 0) drop();
+    const now = current();
+    const origins = new Map(mine.map((c) => [c.name, c.origin]));
+    for (const c of mine) {
+      for (const path of [...before?.splitBy.get(c.name) ?? [], ...now.splitBy.get(c.name) ?? []]) {
+        if (!origins.has(path)) origins.set(path, c.origin);
+      }
+    }
+    changed.emit([...origins].map(([path, origin]) => ({ path, value: now.byPath.get(path), origin })));
+  });
+  let closed = false;
+  let warned = false;
+  const warnIfClosed = (path) => {
+    if (!closed || warned) return;
+    warned = true;
+    console.warn(`[prefs] write to a closed store${path === void 0 ? "" : ` at "${path}"`}; it will not persist`);
+  };
+  return {
+    schema,
+    ...prefWrites({ leaves, cache, selectors: source.selectors, version, selection: () => current().selection, warnIfClosed }),
+    get: (path, read) => {
+      const now = current();
+      if (!read?.weights) return now.byPath.get(path);
+      const leaf = leaves.get(path);
+      const weights = weightsUnder(source.selectors, now.selection, read.weights);
+      return leaf ? resolveHeld(source, leaf, now.held.get(path), weights) : void 0;
+    },
+    locus: (path) => {
+      const held = current().held.get(path);
+      return isPrefLocus(held) ? held : void 0;
+    },
+    loci: () => current().loci,
+    reset: (path) => {
+      warnIfClosed(path);
+      for (const p of leaves.keys()) {
+        if (path === void 0 || p === path || p.startsWith(`${path}.`)) cache.delete(p);
+      }
+    },
+    isSet: (path) => cache.has(path),
+    values: (read) => {
+      const now = current();
+      if (!read?.at) return now.tree;
+      const selection = selectionAt(source.selectors, now.selection, read.at);
+      const weights = selectionWeights(selection);
+      const tree = {};
+      for (const [path, leaf] of leaves) {
+        const set = source.selectors.has(path) ? selection[path] : resolveHeld(source, leaf, now.held.get(path), weights);
+        assignPrefValueAtPath(tree, path, set);
+      }
+      return tree;
+    },
+    unset: () => current().unset,
+    stored: () => storedTree ??= storedRecords(cache),
+    subscribe: (listener) => changed.subscribe(listener),
+    get writable() {
+      return !closed && cache.writable;
+    },
+    get closed() {
+      return closed;
+    },
+    read: () => cache.read(),
+    whenRead: () => cache.whenRead(),
+    flush: () => cache.flush(),
+    close: async () => {
+      closed = true;
+      onClose?.();
+      stopCache();
+      changed = createEmitter();
+      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, options.blends);
+}
+function openPrefsSync(schema, options) {
+  const { cache, stop } = openPrefsCacheSync(options);
+  return createPrefsStore(schema, cache, options.validators, stop, options.migrations?.length ?? 0, options.blends);
+}
+function openPrefsCacheSync(options) {
+  const cache = openRecordsSync({ storage: options.storage, prefix: options.prefix });
+  const stop = watch(cache, options);
+  if (runPrefsMigrations(cache, options.migrations ?? [])) void cache.flush();
+  return { cache, stop };
+}
+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