@wow-two-beta/ui-vue 0.0.4 → 0.0.6

package/dist/foundation/collections/index.js

@@ -1,4 +1,5 @@
-import { E as Equality } from "../../chunks/Equality-DIQYQysz.js";
+import { E as Equality } from "../../chunks/Equality-BabbLMBX.js";
+import { E as ExactNumber } from "../../chunks/ExactNumber-CboRl3_0.js";
 function unique(items, keyFn) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -58,14 +59,14 @@ function insertAt(items, index, value) {
 function removeAt(items, index) {
   const result = [...items];
   const at = Math.trunc(index);
-  if (at < 0 || at >= result.length) return result;
+  if (!Number.isFinite(at) || at < 0 || at >= result.length) return result;
   result.splice(at, 1);
   return result;
 }
 function replaceAt(items, index, value) {
   const result = [...items];
   const at = Math.trunc(index);
-  if (at < 0 || at >= result.length) return result;
+  if (!Number.isFinite(at) || at < 0 || at >= result.length) return result;
   result[at] = value;
   return result;
 }
@@ -92,18 +93,17 @@ function unzip(pairs) {
 }
 function range(start, end, step = 1) {
   if (!Number.isFinite(start) || !Number.isFinite(end)) {
-    throw new RangeError(
-      `range: start and end must be finite, received ${String(start)}..${String(end)}`
-    );
+    throw new RangeError(`range: start and end must be finite, received ${String(start)}..${String(end)}`);
   }
   if (step === 0 || !Number.isFinite(step)) {
     throw new RangeError(`range: step must be a non-zero finite number, received ${String(step)}`);
   }
   const result = [];
-  if (step > 0) {
-    for (let value = start; value < end; value += step) result.push(value);
-  } else {
-    for (let value = start; value > end; value += step) result.push(value);
+  for (let value = start; step > 0 ? value < end : value > end; ) {
+    result.push(value);
+    const next = value + step;
+    if (next === value) throw new RangeError("range: step cannot advance at this magnitude.");
+    value = next;
   }
   return result;
 }
@@ -174,14 +174,14 @@ function mapValues(source, mapFn) {
   const record = source;
   const mapped = {};
   for (const key of Object.keys(record)) {
-    mapped[key] = mapFn(record[key], key);
+    defineEntry(mapped, key, mapFn(record[key], key));
   }
   return mapped;
 }
 function pickKeys(source, keys) {
   const result = {};
   for (const key of keys) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) result[key] = source[key];
+    if (Object.prototype.hasOwnProperty.call(source, key)) defineEntry(result, key, source[key]);
   }
   return result;
 }
@@ -190,13 +190,13 @@ function omitKeys(source, keys) {
   const record = source;
   const result = {};
   for (const key of Object.keys(record)) {
-    if (!omitted.has(key)) result[key] = record[key];
+    if (!omitted.has(key)) defineEntry(result, key, record[key]);
   }
   return result;
 }
 function entriesToRecord(entries) {
   const result = {};
-  for (const [key, value] of entries) result[key] = value;
+  for (const [key, value] of entries) defineEntry(result, key, value);
   return result;
 }
 function recordToEntries(record) {
@@ -205,13 +205,19 @@ function recordToEntries(record) {
 }
 function invertRecord(record) {
   const result = {};
-  for (const [key, value] of recordToEntries(record)) result[value] = key;
+  for (const [key, value] of recordToEntries(record)) defineEntry(result, value, key);
   return result;
 }
+function defineEntry(target, key, value) {
+  Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+}
 function arrayShallowEqual(first, second) {
   if (first === second) return true;
   if (first.length !== second.length) return false;
-  return first.every((item, index) => Object.is(item, second[index]));
+  for (let index = 0; index < first.length; index++) {
+    if (!Object.is(first[index], second[index])) return false;
+  }
+  return true;
 }
 function shallowEqual(first, second) {
   if (Object.is(first, second)) return true;
@@ -220,10 +226,7 @@ function shallowEqual(first, second) {
   if (Array.isArray(first) || Array.isArray(second)) {
     return Array.isArray(first) && Array.isArray(second) && arrayShallowEqual(first, second);
   }
-  return Equality.shallowEquals(
-    first,
-    second
-  );
+  return Equality.shallowEquals(first, second);
 }
 function deepEqual(first, second) {
   return deepEqualWithin(first, second, /* @__PURE__ */ new Map());
@@ -232,6 +235,9 @@ function deepEqualWithin(first, second, seen) {
   if (Object.is(first, second)) return true;
   if (first === null || second === null) return false;
   if (typeof first !== "object" || typeof second !== "object") return false;
+  if (ExactNumber.isExactNumber(first) || ExactNumber.isExactNumber(second)) {
+    return Equality.shallowEquals(first, second);
+  }
   const partners = seen.get(first);
   if (partners?.has(second)) return true;
   if (partners) partners.add(second);
@@ -262,7 +268,10 @@ function compareObjects(first, second, seen) {
   if (Array.isArray(first) || Array.isArray(second)) {
     if (!Array.isArray(first) || !Array.isArray(second)) return false;
     if (first.length !== second.length) return false;
-    return first.every((item, index) => deepEqualWithin(item, second[index], seen));
+    for (let index = 0; index < first.length; index++) {
+      if (!deepEqualWithin(first[index], second[index], seen)) return false;
+    }
+    return true;
   }
   if (first instanceof Map || second instanceof Map) {
     if (!(first instanceof Map) || !(second instanceof Map)) return false;
@@ -330,61 +339,41 @@ function setsEqual(first, second, seen) {
   return true;
 }
 function buildTree(items, options) {
-  const { id, parentId } = options;
   const byId = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const key = id(item);
-    if (!byId.has(key)) byId.set(key, item);
-  }
-  const cyclicIds = detectCyclicIds(items, byId, id, parentId);
-  const childrenById = /* @__PURE__ */ new Map();
-  const roots = [];
-  for (const item of items) {
-    const parent = parentId(item);
-    const isRoot = parent === null || parent === void 0 || !byId.has(parent) || cyclicIds.has(id(item));
-    if (isRoot) {
-      roots.push(item);
-      continue;
-    }
-    const siblings = childrenById.get(parent);
-    if (siblings) siblings.push(item);
-    else childrenById.set(parent, [item]);
-  }
-  const expanding = /* @__PURE__ */ new Set();
-  const toNode = (item) => {
-    const key = id(item);
-    if (expanding.has(key)) return { item, children: [] };
-    expanding.add(key);
-    const children = (childrenById.get(key) ?? []).map(toNode);
-    expanding.delete(key);
-    return { item, children };
-  };
-  return roots.map(toNode);
-}
-function detectCyclicIds(items, byId, id, parentId) {
-  const cyclicIds = /* @__PURE__ */ new Set();
-  for (const item of items) {
-    const start = id(item);
-    if (cyclicIds.has(start)) continue;
+  const nodes = items.map((item, index) => {
+    const key = options.id(item);
+    if (!byId.has(key)) byId.set(key, index);
+    return { item, children: [] };
+  });
+  const parents = items.map((item) => {
+    const key = options.parentId(item);
+    return key === null || key === void 0 ? void 0 : byId.get(key);
+  });
+  const completed = /* @__PURE__ */ new Set();
+  const cyclic = /* @__PURE__ */ new Set();
+  for (let index = 0; index < nodes.length; index++) {
     const path = [];
-    const onPath = /* @__PURE__ */ new Set();
-    let currentId = start;
-    while (currentId !== void 0) {
-      if (onPath.has(currentId)) {
-        const loopStart = path.indexOf(currentId);
-        for (let index = loopStart; index < path.length; index += 1) {
-          cyclicIds.add(path[index]);
-        }
+    const positions = /* @__PURE__ */ new Map();
+    let current = index;
+    while (current !== void 0 && !completed.has(current)) {
+      const position = positions.get(current);
+      if (position !== void 0) {
+        for (let offset = position; offset < path.length; offset++) cyclic.add(path[offset]);
         break;
       }
-      const owner = byId.get(currentId);
-      if (owner === void 0) break;
-      onPath.add(currentId);
-      path.push(currentId);
-      currentId = parentId(owner) ?? void 0;
+      positions.set(current, path.length);
+      path.push(current);
+      current = parents[current];
     }
+    for (const visited of path) completed.add(visited);
   }
-  return cyclicIds;
+  const roots = [];
+  nodes.forEach((node, index) => {
+    const parent = parents[index];
+    if (parent === void 0 || cyclic.has(index)) roots.push(node);
+    else nodes[parent].children.push(node);
+  });
+  return roots;
 }
 function readChildren(node, childrenKey) {
   const children = node[childrenKey];
@@ -392,40 +381,55 @@ function readChildren(node, childrenKey) {
 }
 function flattenTree(nodes, childrenKey = "children") {
   const result = [];
-  const visited = /* @__PURE__ */ new Set();
-  const walk = (level) => {
-    for (const node of level) {
-      if (visited.has(node)) continue;
-      visited.add(node);
+  findInTree(
+    nodes,
+    (node) => {
       result.push(node);
-      walk(readChildren(node, childrenKey));
-    }
-  };
-  walk(nodes);
+      return false;
+    },
+    childrenKey
+  );
   return result;
 }
 function findInTree(nodes, predicate, childrenKey = "children") {
   const visited = /* @__PURE__ */ new Set();
-  const walk = (level, depth) => {
-    for (const node of level) {
-      if (visited.has(node)) continue;
-      visited.add(node);
-      if (predicate(node, depth)) return node;
-      const found = walk(readChildren(node, childrenKey), depth + 1);
-      if (found !== void 0) return found;
+  const stack = [{ nodes, index: 0 }];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (frame.index >= frame.nodes.length) {
+      stack.pop();
+      continue;
     }
-    return void 0;
-  };
-  return walk(nodes, 0);
+    const node = frame.nodes[frame.index++];
+    if (visited.has(node)) continue;
+    visited.add(node);
+    if (predicate(node, stack.length - 1)) return node;
+    stack.push({ nodes: readChildren(node, childrenKey), index: 0 });
+  }
+  return void 0;
 }
 function mapTree(nodes, mapFn) {
-  const walk = (level, depth) => level.map((node) => ({
-    item: mapFn(node.item, depth),
-    children: walk(node.children, depth + 1)
-  }));
-  return walk(nodes, 0);
+  const result = [];
+  const active = /* @__PURE__ */ new Set();
+  const stack = [{ nodes, index: 0, output: result }];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (frame.index >= frame.nodes.length) {
+      if (frame.owner) active.delete(frame.owner);
+      stack.pop();
+      continue;
+    }
+    const node = frame.nodes[frame.index++];
+    if (active.has(node)) throw new TypeError("mapTree: cyclic input is not a tree.");
+    const children = [];
+    frame.output.push({ item: mapFn(node.item, stack.length - 1), children });
+    active.add(node);
+    stack.push({ nodes: node.children, index: 0, output: children, owner: node });
+  }
+  return result;
 }
 export {
+  Equality,
   arrayShallowEqual,
   buildTree,
   chunk,

package/dist/foundation/collections/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/collections/Arrays.ts","../../../src/foundation/collections/SetOps.ts","../../../src/foundation/collections/Records.ts","../../../src/foundation/collections/Comparison.ts","../../../src/foundation/collections/Tree.ts"],"sourcesContent":["// Arrays — the immutable list operations every list-shaped surface re-derives: dedupe, group, split,\n// reorder, and the four positional edits (insert / remove / replace / toggle).\n//\n// WHY A SLICE AND NOT A DEPENDENCY. `lodash` / `remeda` cover most of this, but the SDK ships as a\n// peer-light package: one utility import must not pull a second collection library into every product\n// bundle. Each function here is a handful of lines and the behaviour is pinned by one test file.\n//\n// EVERY FUNCTION RETURNS A NEW ARRAY — including the no-op cases (`move(items, 2, 2)`,\n// `removeAt(items, 99)`). A conditional identity return is the classic reactivity footgun: a caller relying on\n// referential change to re-render would silently stop updating for exactly the inputs that look harmless.\n// The copy is O(n) and n here is a rendered list. (`selection`'s `applySort` deliberately makes the other\n// choice — it returns the input for an empty descriptor list — because an unsorted render is its hot path.)\n//\n// POSITIONAL EDITS CLAMP, THEY DO NOT THROW. Drag-and-drop, keyboard reorder, and server-echoed indices\n// all produce out-of-range values under normal operation; a thrown `RangeError` in a render path turns a\n// cosmetic bug into a blank screen. `chunk` and `range` are the exceptions and DO throw, because a zero or\n// negative step is a programmer error with no sane fallback — and would loop forever.\n\nimport { Equality, type EqualityComparer } from '../utils/Equality';\n\n/**\n * Removes duplicates, keeping the FIRST occurrence of each key and the input's order.\n *\n * Without `keyFn` the item itself is the key, compared with `Set` semantics (SameValueZero — so `NaN`\n * de-duplicates against `NaN`, and `+0` against `-0`). With `keyFn`, the extracted key decides, which is\n * how you de-duplicate rows by `id` while keeping the first-seen row object.\n *\n * @param items The source list; never mutated.\n * @param keyFn Optional key extractor receiving the item and its index.\n * @returns A new array holding the first item per distinct key.\n */\nexport function unique<T, TKey = T>(\n  items: readonly T[],\n  keyFn?: (item: T, index: number) => TKey,\n): T[] {\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  items.forEach((item, index) => {\n    const key = keyFn ? keyFn(item, index) : item;\n    if (seen.has(key)) return;\n    seen.add(key);\n    result.push(item);\n  });\n  return result;\n}\n\n/**\n * Buckets items by an extracted key into a `Map`.\n *\n * A `Map` rather than a plain object for two reasons: keys stay their real type (a numeric or object key\n * is not stringified), and iteration order is the order keys were FIRST seen — a plain object reorders\n * integer-like keys ahead of string ones, which silently rearranges rendered group headings.\n *\n * @param items The source list; never mutated.\n * @param keyFn Extracts the group key from an item and its index.\n * @returns A new `Map` of key to a new array of that key's items, both in first-seen order.\n */\nexport function groupBy<T, TKey>(\n  items: readonly T[],\n  keyFn: (item: T, index: number) => TKey,\n): Map<TKey, T[]> {\n  const groups = new Map<TKey, T[]>();\n  items.forEach((item, index) => {\n    const key = keyFn(item, index);\n    const group = groups.get(key);\n    if (group) group.push(item);\n    else groups.set(key, [item]);\n  });\n  return groups;\n}\n\n/**\n * Splits a list in two by a predicate, in one pass, preserving order in both halves.\n *\n * @param items The source list; never mutated.\n * @param predicate Decides whether an item belongs to the first half.\n * @returns A `[matched, rest]` tuple of two new arrays.\n */\nexport function partition<T>(\n  items: readonly T[],\n  predicate: (item: T, index: number) => boolean,\n): [T[], T[]] {\n  const matched: T[] = [];\n  const rest: T[] = [];\n  items.forEach((item, index) => {\n    (predicate(item, index) ? matched : rest).push(item);\n  });\n  return [matched, rest];\n}\n\n/**\n * Slices a list into consecutive groups of at most `size`. The final group is short when the length is\n * not a multiple of `size`.\n *\n * @param items The source list; never mutated.\n * @param size The maximum group length; must be a positive integer.\n * @returns A new array of new arrays. An empty input yields `[]`, never `[[]]`.\n * @throws {RangeError} When `size` is not a positive integer — a zero or negative size has no meaningful\n * result and would loop forever.\n */\nexport function chunk<T>(items: readonly T[], size: number): T[][] {\n  if (!Number.isInteger(size) || size < 1) {\n    throw new RangeError(`chunk: size must be a positive integer, received ${String(size)}`);\n  }\n  const result: T[][] = [];\n  for (let index = 0; index < items.length; index += size) {\n    result.push(items.slice(index, index + size));\n  }\n  return result;\n}\n\n/**\n * Reorders one item, using drag-and-drop semantics: the item is REMOVED first, then re-inserted at `to`\n * measured in the shortened list. This is the behaviour a pointer drag implies — dropping item 0 onto\n * slot 2 of `[a, b, c, d]` yields `[b, c, a, d]`, i.e. the dragged item lands where the cursor is, not one\n * slot past it. Pairs with `foundation/gestures`' `useDrag`.\n *\n * Both indices are truncated and clamped into range, so an over-drag past either end parks the item at\n * that end instead of throwing or dropping it.\n *\n * @param items The source list; never mutated.\n * @param from The index of the item to move.\n * @param to The index it should occupy afterwards.\n * @returns A new array with the item relocated; a new copy when `from` and `to` resolve to the same slot.\n */\nexport function move<T>(items: readonly T[], from: number, to: number): T[] {\n  const result = [...items];\n  if (result.length === 0) return result;\n  const lastIndex = result.length - 1;\n  const fromIndex = Math.min(Math.max(Math.trunc(from), 0), lastIndex);\n  const toIndex = Math.min(Math.max(Math.trunc(to), 0), lastIndex);\n  if (fromIndex === toIndex) return result;\n  const [moved] = result.splice(fromIndex, 1);\n  result.splice(toIndex, 0, moved as T);\n  return result;\n}\n\n/**\n * Inserts one value at an index. The index is clamped to `[0, length]`, so `length` appends and a\n * negative index prepends.\n *\n * @param items The source list; never mutated.\n * @param index Where the new value should land.\n * @param value The value to insert.\n * @returns A new array one longer than the input.\n */\nexport function insertAt<T>(items: readonly T[], index: number, value: T): T[] {\n  const result = [...items];\n  const at = Math.min(Math.max(Math.trunc(index), 0), result.length);\n  result.splice(at, 0, value);\n  return result;\n}\n\n/**\n * Removes the item at an index. An out-of-range index removes nothing and still returns a fresh copy.\n *\n * @param items The source list; never mutated.\n * @param index The index to drop.\n * @returns A new array, one shorter when the index was in range.\n */\nexport function removeAt<T>(items: readonly T[], index: number): T[] {\n  const result = [...items];\n  const at = Math.trunc(index);\n  if (at < 0 || at >= result.length) return result;\n  result.splice(at, 1);\n  return result;\n}\n\n/**\n * Replaces the item at an index. An out-of-range index replaces nothing and still returns a fresh copy —\n * it never grows the array or punches an `undefined` hole in it.\n *\n * @param items The source list; never mutated.\n * @param index The index to overwrite.\n * @param value The replacement value.\n * @returns A new array of the same length as the input.\n */\nexport function replaceAt<T>(items: readonly T[], index: number, value: T): T[] {\n  const result = [...items];\n  const at = Math.trunc(index);\n  if (at < 0 || at >= result.length) return result;\n  result[at] = value;\n  return result;\n}\n\n/**\n * Adds an item when absent, removes it when present — the checkbox/chip/multi-select primitive.\n *\n * Equality defaults to `foundation/utils`' `Equality.strictEquals` (`Object.is`), which is reference\n * equality for objects; pass `Equality.byKey((row) => row.id)` (or any comparer) when the toggled value is\n * a fresh object each render. EVERY match is removed, so a list that already held duplicates toggles all of\n * them off at once. An added item is appended at the end.\n *\n * @param items The source list; never mutated.\n * @param item The value to toggle.\n * @param equalsFn Decides whether a list entry IS the toggled item.\n * @returns A new array with the item removed or appended.\n */\nexport function toggleItem<T>(\n  items: readonly T[],\n  item: T,\n  equalsFn: EqualityComparer<T> = Equality.strictEquals,\n): T[] {\n  const remaining = items.filter((candidate) => !equalsFn(candidate, item));\n  return remaining.length === items.length ? [...items, item] : remaining;\n}\n\n/**\n * Pairs two lists positionally, stopping at the SHORTER one — the extra tail is dropped rather than\n * padded with `undefined`, so the result type has no holes to narrow away at every call site.\n *\n * @param first The list supplying each pair's first slot.\n * @param second The list supplying each pair's second slot.\n * @returns A new array of `[first, second]` tuples, `min(first.length, second.length)` long.\n */\nexport function zip<TFirst, TSecond>(\n  first: readonly TFirst[],\n  second: readonly TSecond[],\n): Array<[TFirst, TSecond]> {\n  const length = Math.min(first.length, second.length);\n  const result: Array<[TFirst, TSecond]> = [];\n  for (let index = 0; index < length; index += 1) {\n    result.push([first[index] as TFirst, second[index] as TSecond]);\n  }\n  return result;\n}\n\n/**\n * Splits a list of pairs back into two lists — the inverse of {@link zip}.\n *\n * @param pairs The tuples to split.\n * @returns A `[firsts, seconds]` tuple of two new arrays, each as long as `pairs`.\n */\nexport function unzip<TFirst, TSecond>(\n  pairs: readonly (readonly [TFirst, TSecond])[],\n): [TFirst[], TSecond[]] {\n  const first: TFirst[] = [];\n  const second: TSecond[] = [];\n  for (const pair of pairs) {\n    first.push(pair[0]);\n    second.push(pair[1]);\n  }\n  return [first, second];\n}\n\n/**\n * Builds a numeric sequence over the HALF-OPEN interval `[start, end)` — `end` is excluded, so\n * `range(0, items.length)` indexes a list exactly and `range(a, b).length === b - a`.\n *\n * A negative `step` counts down. When the step points away from `end` (`range(0, 5, -1)`) the result is\n * empty rather than infinite.\n *\n * @param start The first value, always included when the range is non-empty.\n * @param end The exclusive bound.\n * @param step The increment; defaults to `1`.\n * @returns A new array of numbers.\n * @throws {RangeError} When `step` is zero or any argument is non-finite — each would loop forever.\n */\nexport function range(start: number, end: number, step = 1): number[] {\n  if (!Number.isFinite(start) || !Number.isFinite(end)) {\n    throw new RangeError(\n      `range: start and end must be finite, received ${String(start)}..${String(end)}`,\n    );\n  }\n  if (step === 0 || !Number.isFinite(step)) {\n    throw new RangeError(`range: step must be a non-zero finite number, received ${String(step)}`);\n  }\n  const result: number[] = [];\n  if (step > 0) {\n    for (let value = start; value < end; value += step) result.push(value);\n  } else {\n    for (let value = start; value > end; value += step) result.push(value);\n  }\n  return result;\n}\n","// SetOps — the four set relations, expressed over ARRAYS rather than `Set`s.\n//\n// WHY ARRAYS IN AND ARRAYS OUT. A `Set` is the right internal index and the wrong public type here: `v-for`\n// renders lists, `key` bindings need a stable order, and a `Set` has no index. Every caller that reached for\n// `new Set([...a].filter(...))` had to spread it straight back to an array anyway, losing order on the way.\n// These take arrays, index with a `Set` internally, and hand back arrays.\n//\n// ORDER IS DEFINED, NOT INCIDENTAL. Results follow the FIRST argument's order, then (for `union` and\n// `symmetricDifference`) the second's. Set theory says these are unordered; a rendered list disagrees, and\n// an undefined order would reshuffle rows on every recompute.\n//\n// SET SEMANTICS MEAN DE-DUPLICATION. All four collapse duplicates within the inputs — `union([a, a], [])`\n// is `[a]`. Use `foundation/collections`' `Arrays` helpers when you want a bag, not a set.\n//\n// The optional `keyFn` is what makes these usable on entities: two fetches return equal-but-not-identical\n// row objects, so `difference(next, previous, (row) => row.id)` is the real-world call, not the identity one.\n\n/** Indexes a list by its comparison key — the shared internal step of every relation below. */\nfunction toKeySet<T, TKey>(items: readonly T[], keyFn?: (item: T) => TKey): Set<TKey | T> {\n  const keys = new Set<TKey | T>();\n  for (const item of items) keys.add(keyFn ? keyFn(item) : item);\n  return keys;\n}\n\n/**\n * Everything in either list, de-duplicated by key.\n *\n * Order is all of `first` followed by the members of `second` not already present. When two items share a\n * key, the one from `first` is the one kept — the left list wins, which is what an \"apply these updates on\n * top of what I have\" call expects.\n *\n * @param first The list whose items and order take precedence.\n * @param second The list contributing anything new.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function union<T, TKey = T>(\n  first: readonly T[],\n  second: readonly T[],\n  keyFn?: (item: T) => TKey,\n): T[] {\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  for (const item of first) {\n    const key = keyFn ? keyFn(item) : item;\n    if (seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  for (const item of second) {\n    const key = keyFn ? keyFn(item) : item;\n    if (seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  return result;\n}\n\n/**\n * Only the items whose key appears in BOTH lists, de-duplicated, in `first`'s order and holding `first`'s\n * item instances.\n *\n * @param first The list supplying the result's items and order.\n * @param second The list acting as the membership test.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function intersection<T, TKey = T>(\n  first: readonly T[],\n  second: readonly T[],\n  keyFn?: (item: T) => TKey,\n): T[] {\n  const other = toKeySet(second, keyFn);\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  for (const item of first) {\n    const key = keyFn ? keyFn(item) : item;\n    if (!other.has(key) || seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  return result;\n}\n\n/**\n * The items of `first` whose key does NOT appear in `second`, de-duplicated, in `first`'s order.\n *\n * Asymmetric by definition: `difference(a, b)` answers \"what did I gain\", `difference(b, a)` answers \"what\n * did I lose\".\n *\n * @param first The list to subtract from.\n * @param second The list to subtract.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function difference<T, TKey = T>(\n  first: readonly T[],\n  second: readonly T[],\n  keyFn?: (item: T) => TKey,\n): T[] {\n  const other = toKeySet(second, keyFn);\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  for (const item of first) {\n    const key = keyFn ? keyFn(item) : item;\n    if (other.has(key) || seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  return result;\n}\n\n/**\n * Everything present in exactly one of the two lists — the \"what changed\" relation, `first`-only entries\n * followed by `second`-only entries.\n *\n * @param first The left list.\n * @param second The right list.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function symmetricDifference<T, TKey = T>(\n  first: readonly T[],\n  second: readonly T[],\n  keyFn?: (item: T) => TKey,\n): T[] {\n  return [...difference(first, second, keyFn), ...difference(second, first, keyFn)];\n}\n","// Records — the keyed-collection half of the slice: turning a list into a lookup, and reshaping the\n// lookup without mutating it.\n//\n// MAP FOR DERIVED LOOKUPS, RECORD FOR DECLARED SHAPES. `keyBy` returns a `Map` because the key comes from\n// the data at runtime and may be any type — a plain object would stringify a numeric id and reorder\n// integer-like keys ahead of string ones. `pickKeys` / `omitKeys` / `invertRecord` take records because\n// their keys are part of the caller's declared type, and the return type is derived from it (`Pick` /\n// `Omit`), which is the whole reason to prefer them over hand-written destructuring.\n//\n// `mapValues` straddles the two on purpose: it is overloaded so `groupBy(...)` → `mapValues(groups, (rows)\n// => rows.length)` keeps its `Map`, while a config record stays a record. One name, because the intent is\n// identical and a caller should not have to remember which container they are holding.\n//\n// STRING KEYS ONLY on the record helpers. They walk `Object.keys`, so own enumerable STRING keys are\n// visited: symbol keys are skipped, and a numeric key comes back as its string form (JavaScript's rule,\n// not this slice's). Prototype-inherited properties are never copied.\n\n/**\n * Indexes a list by an extracted key. The LAST item wins on a duplicate key, matching the \"latest write\n * of this id\" reading a lookup usually wants — use {@link groupBy} instead when duplicates are meaningful.\n *\n * @param items The source list; never mutated.\n * @param keyFn Extracts an item's key from the item and its index.\n * @returns A new `Map` in first-seen key order.\n * @see groupBy — the same shape when a key can legitimately hold several items.\n */\nexport function keyBy<T, TKey>(\n  items: readonly T[],\n  keyFn: (item: T, index: number) => TKey,\n): Map<TKey, T> {\n  const result = new Map<TKey, T>();\n  items.forEach((item, index) => {\n    result.set(keyFn(item, index), item);\n  });\n  return result;\n}\n\n/**\n * Transforms every value, keeping the keys and their order. Overloaded on the container: a `Map` in gives\n * a `Map` out, a record in gives a record out.\n *\n * @param source The `Map` whose values should be transformed; never mutated.\n * @param mapFn Produces the replacement value from the current value and its key.\n * @returns A new `Map` with the same keys in the same order.\n */\nexport function mapValues<TKey, TValue, TResult>(\n  source: ReadonlyMap<TKey, TValue>,\n  mapFn: (value: TValue, key: TKey) => TResult,\n): Map<TKey, TResult>;\n/**\n * Transforms every value, keeping the keys and their order.\n *\n * @param source The record whose values should be transformed; never mutated.\n * @param mapFn Produces the replacement value from the current value and its key.\n * @returns A new record with the same own enumerable string keys.\n */\nexport function mapValues<TKey extends PropertyKey, TValue, TResult>(\n  source: Readonly<Record<TKey, TValue>>,\n  mapFn: (value: TValue, key: TKey) => TResult,\n): Record<TKey, TResult>;\nexport function mapValues(\n  source: ReadonlyMap<unknown, unknown> | object,\n  mapFn: (value: never, key: never) => unknown,\n): Map<unknown, unknown> | Record<string, unknown> {\n  if (source instanceof Map) {\n    const mapped = new Map<unknown, unknown>();\n    for (const [key, value] of source.entries()) {\n      mapped.set(key, mapFn(value as never, key as never));\n    }\n    return mapped;\n  }\n  const record = source as Record<string, unknown>;\n  const mapped: Record<string, unknown> = {};\n  for (const key of Object.keys(record)) {\n    mapped[key] = mapFn(record[key] as never, key as never);\n  }\n  return mapped;\n}\n\n/**\n * Copies only the named keys into a new object.\n *\n * A key the source does not actually own is SKIPPED rather than copied as `undefined` — otherwise\n * `pickKeys(partial, ['a', 'b'])` would fabricate a `b` property that fails a `'b' in result` check and\n * serialises as an explicit null in a request body.\n *\n * @param source The object to read from; never mutated.\n * @param keys The keys to keep.\n * @returns A new object holding only the present named keys.\n */\nexport function pickKeys<T extends object, TKey extends keyof T>(\n  source: T,\n  keys: readonly TKey[],\n): Pick<T, TKey> {\n  const result = {} as Pick<T, TKey>;\n  for (const key of keys) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) result[key] = source[key];\n  }\n  return result;\n}\n\n/**\n * Copies every own enumerable string key EXCEPT the named ones into a new object — the immutable spelling\n * of `delete`, and the typed one (the result type loses the removed keys).\n *\n * @param source The object to read from; never mutated.\n * @param keys The keys to drop.\n * @returns A new object without the named keys.\n */\nexport function omitKeys<T extends object, TKey extends keyof T>(\n  source: T,\n  keys: readonly TKey[],\n): Omit<T, TKey> {\n  const omitted = new Set<PropertyKey>(keys);\n  const record = source as Record<string, unknown>;\n  const result: Record<string, unknown> = {};\n  for (const key of Object.keys(record)) {\n    if (!omitted.has(key)) result[key] = record[key];\n  }\n  return result as Omit<T, TKey>;\n}\n\n/**\n * Collects key/value pairs into a record. Accepts any iterable, so a `Map`, a `URLSearchParams`, or the\n * output of {@link recordToEntries} all feed it directly. The LAST pair wins on a duplicate key.\n *\n * @param entries The pairs to collect.\n * @returns A new record.\n */\nexport function entriesToRecord<TKey extends PropertyKey, TValue>(\n  entries: Iterable<readonly [TKey, TValue]>,\n): Record<TKey, TValue> {\n  const result = {} as Record<TKey, TValue>;\n  for (const [key, value] of entries) result[key] = value;\n  return result;\n}\n\n/**\n * Lists a record's own enumerable string keys with their values, in `Object.keys` order — the typed\n * counterpart to `Object.entries`, which widens every key to `string`.\n *\n * @param record The record to read; never mutated.\n * @returns A new array of `[key, value]` tuples.\n */\nexport function recordToEntries<TKey extends PropertyKey, TValue>(\n  record: Readonly<Record<TKey, TValue>>,\n): Array<[TKey, TValue]> {\n  const keys = Object.keys(record) as Array<TKey & string>;\n  return keys.map((key) => [key, record[key]]);\n}\n\n/**\n * Swaps keys and values. The LAST key wins when two keys share a value, so inverting a non-injective\n * record is lossy by design — the alternative (an array of keys per value) is {@link groupBy}'s job.\n *\n * @param record The record to invert; never mutated.\n * @returns A new record mapping each value back to a key.\n */\nexport function invertRecord<TKey extends PropertyKey, TValue extends PropertyKey>(\n  record: Readonly<Record<TKey, TValue>>,\n): Record<TValue, TKey> {\n  const result = {} as Record<TValue, TKey>;\n  for (const [key, value] of recordToEntries(record)) result[value] = key;\n  return result;\n}\n","// Comparison — structural equality for memo boundaries: `v-memo`, `computed` guards, \"is this form\n// dirty\", \"did the server actually send something new\".\n//\n// THREE FUNCTIONS, THREE COSTS, PICK DELIBERATELY. `arrayShallowEqual` is O(n) reference checks and is\n// what a list-prop memo wants. `shallowEqual` is the same one level deep on either arrays or objects.\n// `deepEqual` walks the whole structure — correct, and the one you must not put on a hot path over a large\n// payload without meaning to.\n//\n// `shallowEqual` DELEGATES its plain-object case to `foundation/utils`' `Equality.shallowEquals` rather\n// than re-deriving it; this file only adds the array dispatch and the deep walk, which that helper\n// deliberately does not do.\n//\n// WHY A DEEP VARIANT LIVES HERE AT ALL. `forms-engine` already carries a local `deepEqual`, scoped to form\n// values (primitives, plain objects, arrays, `Date`, `File`/`Blob`) and reachable only from that layer —\n// `foundation` may not import upward. This one is the general one: it additionally handles `Map`, `Set`,\n// `RegExp`, `ArrayBuffer` and typed arrays, and it terminates on circular structures.\n//\n// CIRCULARITY IS CO-INDUCTIVE. A pair already being compared higher in the stack is ASSUMED equal, so two\n// structures that loop the same way compare equal instead of recursing forever — the standard rule, and\n// the only one that terminates. The in-progress pair is dropped again when a comparison fails, because the\n// `Map`/`Set` matchers below probe candidate pairs whose failure must not be remembered as a success.\n//\n// TYPED ARRAYS COMPARE BYTE-WISE (same constructor, same byte length, same bytes). One consequence worth\n// knowing: `+0` and `-0` differ in bits, so they compare UNEQUAL inside a `Float64Array` while comparing\n// equal as plain numbers. Bit-equality is the right reading for a buffer.\n\nimport { Equality } from '../utils/Equality';\n\n/**\n * Compares two arrays element-by-element with `Object.is` — no recursion, no allocation.\n *\n * The cheapest correct check for a list prop rebuilt each render from stable item references (a `.map()`\n * over cached rows, a `computed` dependency). `NaN` equals `NaN`; two structurally identical but distinct\n * objects do not.\n *\n * @param first The left array.\n * @param second The right array.\n * @returns `true` when both have the same length and every index holds the same value.\n */\nexport function arrayShallowEqual<T>(first: readonly T[], second: readonly T[]): boolean {\n  if (first === second) return true;\n  if (first.length !== second.length) return false;\n  return first.every((item, index) => Object.is(item, second[index]));\n}\n\n/**\n * Compares two values one level deep.\n *\n * Dispatches on shape: identical values short-circuit, two arrays go to {@link arrayShallowEqual}, two\n * objects compare their own enumerable keys with `Object.is`, and anything else (a primitive pair that was\n * not already identical, or a mismatched pair such as array vs object) is unequal.\n *\n * @param first The left value.\n * @param second The right value.\n * @returns `true` when the two are equal at one level of depth.\n */\nexport function shallowEqual(first: unknown, second: unknown): boolean {\n  if (Object.is(first, second)) return true;\n  if (first === null || second === null) return false;\n  if (typeof first !== 'object' || typeof second !== 'object') return false;\n  if (Array.isArray(first) || Array.isArray(second)) {\n    return Array.isArray(first) && Array.isArray(second) && arrayShallowEqual(first, second);\n  }\n  return Equality.shallowEquals(\n    first as Record<string, unknown>,\n    second as Record<string, unknown>,\n  );\n}\n\n/**\n * Compares two values structurally, all the way down.\n *\n * Understands `Date` (by timestamp), `RegExp` (source + flags), `Array`, `Map`, `Set`, `ArrayBuffer` and\n * every typed array / `DataView` (byte-wise), and plain objects (own enumerable string keys). `NaN` equals\n * `NaN`. Anything else falls back to `Object.is`, so two distinct `class` instances with equal fields DO\n * compare equal — the walk is structural and does not check constructors outside the built-ins above.\n *\n * Terminates on circular structures: a pair already under comparison is treated as equal.\n *\n * @param first The left value.\n * @param second The right value.\n * @returns `true` when the two are structurally equal.\n */\nexport function deepEqual(first: unknown, second: unknown): boolean {\n  return deepEqualWithin(first, second, new Map<object, Set<object>>());\n}\n\n/** Runs one comparison against the set of pairs already under comparison on this walk. */\nfunction deepEqualWithin(\n  first: unknown,\n  second: unknown,\n  seen: Map<object, Set<object>>,\n): boolean {\n  if (Object.is(first, second)) return true;\n  if (first === null || second === null) return false;\n  if (typeof first !== 'object' || typeof second !== 'object') return false;\n\n  const partners = seen.get(first);\n  if (partners?.has(second)) return true;\n  if (partners) partners.add(second);\n  else seen.set(first, new Set<object>([second]));\n\n  const isEqual = compareObjects(first, second, seen);\n  // A failed probe must not linger as a remembered success — see the header note on `Map`/`Set` matching.\n  if (!isEqual) seen.get(first)?.delete(second);\n  return isEqual;\n}\n\n/** Dispatches two non-null objects to the branch that matches their built-in type. */\nfunction compareObjects(first: object, second: object, seen: Map<object, Set<object>>): boolean {\n  if (first instanceof Date || second instanceof Date) {\n    return (\n      first instanceof Date &&\n      second instanceof Date &&\n      Object.is(first.getTime(), second.getTime())\n    );\n  }\n  if (first instanceof RegExp || second instanceof RegExp) {\n    return (\n      first instanceof RegExp &&\n      second instanceof RegExp &&\n      first.source === second.source &&\n      first.flags === second.flags\n    );\n  }\n  if (ArrayBuffer.isView(first) || ArrayBuffer.isView(second)) {\n    if (!ArrayBuffer.isView(first) || !ArrayBuffer.isView(second)) return false;\n    if (first.constructor !== second.constructor) return false;\n    return bytesEqual(\n      new Uint8Array(first.buffer, first.byteOffset, first.byteLength),\n      new Uint8Array(second.buffer, second.byteOffset, second.byteLength),\n    );\n  }\n  if (first instanceof ArrayBuffer || second instanceof ArrayBuffer) {\n    if (!(first instanceof ArrayBuffer) || !(second instanceof ArrayBuffer)) return false;\n    return bytesEqual(new Uint8Array(first), new Uint8Array(second));\n  }\n  if (Array.isArray(first) || Array.isArray(second)) {\n    if (!Array.isArray(first) || !Array.isArray(second)) return false;\n    if (first.length !== second.length) return false;\n    return first.every((item, index) => deepEqualWithin(item, second[index], seen));\n  }\n  if (first instanceof Map || second instanceof Map) {\n    if (!(first instanceof Map) || !(second instanceof Map)) return false;\n    if (first.size !== second.size) return false;\n    return mapsEqual(first, second, seen);\n  }\n  if (first instanceof Set || second instanceof Set) {\n    if (!(first instanceof Set) || !(second instanceof Set)) return false;\n    if (first.size !== second.size) return false;\n    return setsEqual(first, second, seen);\n  }\n\n  const leftKeys = Object.keys(first);\n  const rightKeys = Object.keys(second);\n  if (leftKeys.length !== rightKeys.length) return false;\n  const left = first as Record<string, unknown>;\n  const right = second as Record<string, unknown>;\n  return leftKeys.every(\n    (key) =>\n      Object.prototype.hasOwnProperty.call(second, key) &&\n      deepEqualWithin(left[key], right[key], seen),\n  );\n}\n\n/** Compares two byte views of equal-or-different length. */\nfunction bytesEqual(first: Uint8Array, second: Uint8Array): boolean {\n  if (first.length !== second.length) return false;\n  for (let index = 0; index < first.length; index += 1) {\n    if (first[index] !== second[index]) return false;\n  }\n  return true;\n}\n\n/**\n * Compares two equally-sized maps. Takes the direct route when every key of `first` is a key of `second`\n * (the string/number-key case, O(n)); otherwise falls back to matching each entry against an unclaimed\n * entry of `second`, which is the only correct answer when keys are themselves objects.\n */\nfunction mapsEqual(\n  first: ReadonlyMap<unknown, unknown>,\n  second: ReadonlyMap<unknown, unknown>,\n  seen: Map<object, Set<object>>,\n): boolean {\n  let hasEveryKey = true;\n  for (const key of first.keys()) {\n    if (!second.has(key)) {\n      hasEveryKey = false;\n      break;\n    }\n  }\n  if (hasEveryKey) {\n    for (const [key, value] of first) {\n      if (!deepEqualWithin(value, second.get(key), seen)) return false;\n    }\n    return true;\n  }\n\n  const unclaimed = [...second.entries()];\n  for (const [key, value] of first) {\n    const index = unclaimed.findIndex(\n      (entry) =>\n        deepEqualWithin(key, entry[0], seen) && deepEqualWithin(value, entry[1], seen),\n    );\n    if (index === -1) return false;\n    unclaimed.splice(index, 1);\n  }\n  return true;\n}\n\n/**\n * Compares two equally-sized sets. Members present in both by identity are settled first and cost nothing;\n * only the structural leftovers are matched pairwise.\n */\nfunction setsEqual(\n  first: ReadonlySet<unknown>,\n  second: ReadonlySet<unknown>,\n  seen: Map<object, Set<object>>,\n): boolean {\n  const unmatched: unknown[] = [];\n  for (const member of first) {\n    if (!second.has(member)) unmatched.push(member);\n  }\n  if (unmatched.length === 0) return true;\n\n  const candidates = [...second].filter((member) => !first.has(member));\n  if (candidates.length !== unmatched.length) return false;\n  for (const member of unmatched) {\n    const index = candidates.findIndex((candidate) => deepEqualWithin(member, candidate, seen));\n    if (index === -1) return false;\n    candidates.splice(index, 1);\n  }\n  return true;\n}\n","// Tree — turning the flat `{ id, parentId }` list an API returns into something a tree view can render,\n// and walking it once it is nested.\n//\n// THE OUTPUT WRAPS, IT DOES NOT SPREAD. `buildTree` returns `TreeNode<T>` — `{ item, children }` — rather\n// than `{ ...item, children }`. Spreading copies every row (wasteful on a large list), breaks referential\n// equality against the source rows (so every memo downstream misses), and collides the moment a row has\n// its own `children` field. The wrapper holds the ORIGINAL item reference.\n//\n// SERVER DATA IS NOT A TREE UNTIL PROVEN. Two malformed shapes arrive in practice and neither may throw or\n// hang, because the alternative is a blank screen for one bad row:\n//\n//   1. ORPHAN — `parentId` names a row that is not in the list (deleted, or filtered out by paging). The\n//      orphan is PROMOTED TO A ROOT. Dropping it would silently hide data; a root is visible and wrong in\n//      a way a user can report.\n//   2. CYCLE — a parent chain that loops (`a → b → c → a`, or a row that is its own parent). Every row ON\n//      the cycle is PROMOTED TO A ROOT and its upward link is severed. Rows merely BELOW a cycle keep\n//      their parent and nest normally under whichever cycle member became a root. Nothing is dropped and\n//      every row appears exactly once. Detection is an explicit upward walk per row with an on-path set,\n//      so it terminates by construction.\n//\n// The node builder additionally guards on the id currently being expanded. That is not redundant with the\n// cycle detection above: it covers DUPLICATE ids, where two different rows claim the same id and the\n// parent index can otherwise hand a row back to itself.\n//\n// `flattenTree` / `findInTree` take a `childrenKey` because a consumer's own nested shape (`items`,\n// `nodes`, `subRows`) is as common as this slice's own, and both guard against a self-referential node so\n// a hand-built structure cannot hang them either.\n\n/** One node of a built tree — the source item plus the items that named it as parent. */\nexport interface TreeNode<T> {\n  /** The source item, by reference — never a copy, so memo comparisons against the input still hit. */\n  readonly item: T;\n  /** The direct children, in the order the source list listed them. Empty for a leaf. */\n  readonly children: ReadonlyArray<TreeNode<T>>;\n}\n\n/** The two accessors {@link buildTree} needs to read a flat list's parent/child relation. */\nexport interface BuildTreeOptions<T, TId> {\n  /** Reads an item's own identity. */\n  readonly id: (item: T) => TId;\n  /** Reads the id of an item's parent, or a nullish value when the item is a root. */\n  readonly parentId: (item: T) => TId | null | undefined;\n}\n\n/**\n * Nests a flat list into roots-with-children.\n *\n * Root order and sibling order both follow the input's order — no sorting happens here, deliberately.\n * Ordering a tree is `foundation/selection`'s job (`applySort` over the flat list before building, or over\n * a node's `children` after); a second comparator in this slice would let a tree order its rows\n * differently from the table beside it.\n *\n * Malformed input is tolerated, not rejected: an item whose parent is missing becomes a root, and an item\n * on a cyclic parent chain becomes a root with its upward link severed. Neither case drops an item, and\n * neither hangs. A duplicate id resolves to its first occurrence for parent lookups.\n *\n * @param items The flat list; never mutated, and its item references are reused in the result.\n * @param options The `id` / `parentId` accessors.\n * @returns A new array of root nodes.\n */\nexport function buildTree<T, TId>(\n  items: readonly T[],\n  options: BuildTreeOptions<T, TId>,\n): TreeNode<T>[] {\n  const { id, parentId } = options;\n\n  const byId = new Map<TId, T>();\n  for (const item of items) {\n    const key = id(item);\n    if (!byId.has(key)) byId.set(key, item);\n  }\n\n  const cyclicIds = detectCyclicIds(items, byId, id, parentId);\n\n  const childrenById = new Map<TId, T[]>();\n  const roots: T[] = [];\n  for (const item of items) {\n    const parent = parentId(item);\n    const isRoot =\n      parent === null || parent === undefined || !byId.has(parent) || cyclicIds.has(id(item));\n    if (isRoot) {\n      roots.push(item);\n      continue;\n    }\n    const siblings = childrenById.get(parent);\n    if (siblings) siblings.push(item);\n    else childrenById.set(parent, [item]);\n  }\n\n  const expanding = new Set<TId>();\n  const toNode = (item: T): TreeNode<T> => {\n    const key = id(item);\n    // Duplicate-id guard: a second row claiming an id already on the path would otherwise re-expand the\n    // same child list forever. It renders as a leaf instead.\n    if (expanding.has(key)) return { item, children: [] };\n    expanding.add(key);\n    const children = (childrenById.get(key) ?? []).map(toNode);\n    expanding.delete(key);\n    return { item, children };\n  };\n\n  return roots.map(toNode);\n}\n\n/**\n * Collects every id that sits ON a parent cycle. Walks upward from each item with an on-path set, so the\n * walk is bounded by the chain length and a loop is caught the moment it revisits an id.\n */\nfunction detectCyclicIds<T, TId>(\n  items: readonly T[],\n  byId: ReadonlyMap<TId, T>,\n  id: (item: T) => TId,\n  parentId: (item: T) => TId | null | undefined,\n): Set<TId> {\n  const cyclicIds = new Set<TId>();\n  for (const item of items) {\n    const start = id(item);\n    if (cyclicIds.has(start)) continue;\n\n    const path: TId[] = [];\n    const onPath = new Set<TId>();\n    let currentId: TId | undefined = start;\n    while (currentId !== undefined) {\n      if (onPath.has(currentId)) {\n        // Only the suffix from the revisited id onwards is the loop; anything before it merely leads in.\n        const loopStart = path.indexOf(currentId);\n        for (let index = loopStart; index < path.length; index += 1) {\n          cyclicIds.add(path[index] as TId);\n        }\n        break;\n      }\n      const owner = byId.get(currentId);\n      if (owner === undefined) break;\n      onPath.add(currentId);\n      path.push(currentId);\n      currentId = parentId(owner) ?? undefined;\n    }\n  }\n  return cyclicIds;\n}\n\n/** Reads a node's children under the configured key, treating anything non-array as \"no children\". */\nfunction readChildren<TNode extends object>(\n  node: TNode,\n  childrenKey: PropertyKey,\n): readonly TNode[] {\n  const children = (node as Record<PropertyKey, unknown>)[childrenKey];\n  return Array.isArray(children) ? (children as TNode[]) : [];\n}\n\n/**\n * Walks a nested structure depth-first, pre-order, into one flat list — parent before its children, which\n * is the order a collapsed/expanded tree view renders rows in.\n *\n * A node already visited is skipped, so a self-referential structure terminates and each node appears once.\n *\n * @param nodes The roots to walk; never mutated, and node references are reused in the result.\n * @param childrenKey The property holding a node's children; defaults to `'children'`.\n * @returns A new flat array of the same node objects.\n */\nexport function flattenTree<TNode extends object>(\n  nodes: readonly TNode[],\n  childrenKey: PropertyKey = 'children',\n): TNode[] {\n  const result: TNode[] = [];\n  const visited = new Set<TNode>();\n  const walk = (level: readonly TNode[]): void => {\n    for (const node of level) {\n      if (visited.has(node)) continue;\n      visited.add(node);\n      result.push(node);\n      walk(readChildren(node, childrenKey));\n    }\n  };\n  walk(nodes);\n  return result;\n}\n\n/**\n * Finds the first node matching a predicate, depth-first, pre-order — the lookup behind \"select the node\n * for this route\" and \"reveal the row with this id\".\n *\n * @param nodes The roots to search.\n * @param predicate Receives each node and its 0-based depth.\n * @param childrenKey The property holding a node's children; defaults to `'children'`.\n * @returns The matching node, or `undefined` when nothing matches.\n */\nexport function findInTree<TNode extends object>(\n  nodes: readonly TNode[],\n  predicate: (node: TNode, depth: number) => boolean,\n  childrenKey: PropertyKey = 'children',\n): TNode | undefined {\n  const visited = new Set<TNode>();\n  const walk = (level: readonly TNode[], depth: number): TNode | undefined => {\n    for (const node of level) {\n      if (visited.has(node)) continue;\n      visited.add(node);\n      if (predicate(node, depth)) return node;\n      const found = walk(readChildren(node, childrenKey), depth + 1);\n      if (found !== undefined) return found;\n    }\n    return undefined;\n  };\n  return walk(nodes, 0);\n}\n\n/**\n * Rebuilds a {@link TreeNode} tree with every item transformed, keeping the shape and the order.\n *\n * Typed to this slice's node shape rather than a `childrenKey`, because the result has to BE a tree: a\n * generic nested object could not be reassembled without knowing which key to write back.\n *\n * @param nodes The roots to map; never mutated.\n * @param mapFn Produces the replacement item from the current item and its 0-based depth.\n * @returns A new tree of new nodes.\n */\nexport function mapTree<T, TResult>(\n  nodes: readonly TreeNode<T>[],\n  mapFn: (item: T, depth: number) => TResult,\n): TreeNode<TResult>[] {\n  const walk = (level: readonly TreeNode<T>[], depth: number): TreeNode<TResult>[] =>\n    level.map((node) => ({\n      item: mapFn(node.item, depth),\n      children: walk(node.children, depth + 1),\n    }));\n  return walk(nodes, 0);\n}\n"],"names":["mapped"],"mappings":";AA+BO,SAAS,OACd,OACA,OACK;AACL,QAAM,2BAAW,IAAA;AACjB,QAAM,SAAc,CAAA;AACpB,QAAM,QAAQ,CAAC,MAAM,UAAU;AAC7B,UAAM,MAAM,QAAQ,MAAM,MAAM,KAAK,IAAI;AACzC,QAAI,KAAK,IAAI,GAAG,EAAG;AACnB,SAAK,IAAI,GAAG;AACZ,WAAO,KAAK,IAAI;AAAA,EAClB,CAAC;AACD,SAAO;AACT;AAaO,SAAS,QACd,OACA,OACgB;AAChB,QAAM,6BAAa,IAAA;AACnB,QAAM,QAAQ,CAAC,MAAM,UAAU;AAC7B,UAAM,MAAM,MAAM,MAAM,KAAK;AAC7B,UAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,QAAI,MAAO,OAAM,KAAK,IAAI;AAAA,QACrB,QAAO,IAAI,KAAK,CAAC,IAAI,CAAC;AAAA,EAC7B,CAAC;AACD,SAAO;AACT;AASO,SAAS,UACd,OACA,WACY;AACZ,QAAM,UAAe,CAAA;AACrB,QAAM,OAAY,CAAA;AAClB,QAAM,QAAQ,CAAC,MAAM,UAAU;AAC7B,KAAC,UAAU,MAAM,KAAK,IAAI,UAAU,MAAM,KAAK,IAAI;AAAA,EACrD,CAAC;AACD,SAAO,CAAC,SAAS,IAAI;AACvB;AAYO,SAAS,MAAS,OAAqB,MAAqB;AACjE,MAAI,CAAC,OAAO,UAAU,IAAI,KAAK,OAAO,GAAG;AACvC,UAAM,IAAI,WAAW,oDAAoD,OAAO,IAAI,CAAC,EAAE;AAAA,EACzF;AACA,QAAM,SAAgB,CAAA;AACtB,WAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,MAAM;AACvD,WAAO,KAAK,MAAM,MAAM,OAAO,QAAQ,IAAI,CAAC;AAAA,EAC9C;AACA,SAAO;AACT;AAgBO,SAAS,KAAQ,OAAqB,MAAc,IAAiB;AAC1E,QAAM,SAAS,CAAC,GAAG,KAAK;AACxB,MAAI,OAAO,WAAW,EAAG,QAAO;AAChC,QAAM,YAAY,OAAO,SAAS;AAClC,QAAM,YAAY,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC,GAAG,SAAS;AACnE,QAAM,UAAU,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS;AAC/D,MAAI,cAAc,QAAS,QAAO;AAClC,QAAM,CAAC,KAAK,IAAI,OAAO,OAAO,WAAW,CAAC;AAC1C,SAAO,OAAO,SAAS,GAAG,KAAU;AACpC,SAAO;AACT;AAWO,SAAS,SAAY,OAAqB,OAAe,OAAe;AAC7E,QAAM,SAAS,CAAC,GAAG,KAAK;AACxB,QAAM,KAAK,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,KAAK,GAAG,CAAC,GAAG,OAAO,MAAM;AACjE,SAAO,OAAO,IAAI,GAAG,KAAK;AAC1B,SAAO;AACT;AASO,SAAS,SAAY,OAAqB,OAAoB;AACnE,QAAM,SAAS,CAAC,GAAG,KAAK;AACxB,QAAM,KAAK,KAAK,MAAM,KAAK;AAC3B,MAAI,KAAK,KAAK,MAAM,OAAO,OAAQ,QAAO;AAC1C,SAAO,OAAO,IAAI,CAAC;AACnB,SAAO;AACT;AAWO,SAAS,UAAa,OAAqB,OAAe,OAAe;AAC9E,QAAM,SAAS,CAAC,GAAG,KAAK;AACxB,QAAM,KAAK,KAAK,MAAM,KAAK;AAC3B,MAAI,KAAK,KAAK,MAAM,OAAO,OAAQ,QAAO;AAC1C,SAAO,EAAE,IAAI;AACb,SAAO;AACT;AAeO,SAAS,WACd,OACA,MACA,WAAgC,SAAS,cACpC;AACL,QAAM,YAAY,MAAM,OAAO,CAAC,cAAc,CAAC,SAAS,WAAW,IAAI,CAAC;AACxE,SAAO,UAAU,WAAW,MAAM,SAAS,CAAC,GAAG,OAAO,IAAI,IAAI;AAChE;AAUO,SAAS,IACd,OACA,QAC0B;AAC1B,QAAM,SAAS,KAAK,IAAI,MAAM,QAAQ,OAAO,MAAM;AACnD,QAAM,SAAmC,CAAA;AACzC,WAAS,QAAQ,GAAG,QAAQ,QAAQ,SAAS,GAAG;AAC9C,WAAO,KAAK,CAAC,MAAM,KAAK,GAAa,OAAO,KAAK,CAAY,CAAC;AAAA,EAChE;AACA,SAAO;AACT;AAQO,SAAS,MACd,OACuB;AACvB,QAAM,QAAkB,CAAA;AACxB,QAAM,SAAoB,CAAA;AAC1B,aAAW,QAAQ,OAAO;AACxB,UAAM,KAAK,KAAK,CAAC,CAAC;AAClB,WAAO,KAAK,KAAK,CAAC,CAAC;AAAA,EACrB;AACA,SAAO,CAAC,OAAO,MAAM;AACvB;AAeO,SAAS,MAAM,OAAe,KAAa,OAAO,GAAa;AACpE,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,CAAC,OAAO,SAAS,GAAG,GAAG;AACpD,UAAM,IAAI;AAAA,MACR,iDAAiD,OAAO,KAAK,CAAC,KAAK,OAAO,GAAG,CAAC;AAAA,IAAA;AAAA,EAElF;AACA,MAAI,SAAS,KAAK,CAAC,OAAO,SAAS,IAAI,GAAG;AACxC,UAAM,IAAI,WAAW,0DAA0D,OAAO,IAAI,CAAC,EAAE;AAAA,EAC/F;AACA,QAAM,SAAmB,CAAA;AACzB,MAAI,OAAO,GAAG;AACZ,aAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS,KAAM,QAAO,KAAK,KAAK;AAAA,EACvE,OAAO;AACL,aAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS,KAAM,QAAO,KAAK,KAAK;AAAA,EACvE;AACA,SAAO;AACT;AChQA,SAAS,SAAkB,OAAqB,OAA0C;AACxF,QAAM,2BAAW,IAAA;AACjB,aAAW,QAAQ,MAAO,MAAK,IAAI,QAAQ,MAAM,IAAI,IAAI,IAAI;AAC7D,SAAO;AACT;AAcO,SAAS,MACd,OACA,QACA,OACK;AACL,QAAM,2BAAW,IAAA;AACjB,QAAM,SAAc,CAAA;AACpB,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,QAAQ,MAAM,IAAI,IAAI;AAClC,QAAI,KAAK,IAAI,GAAG,EAAG;AACnB,SAAK,IAAI,GAAG;AACZ,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,aAAW,QAAQ,QAAQ;AACzB,UAAM,MAAM,QAAQ,MAAM,IAAI,IAAI;AAClC,QAAI,KAAK,IAAI,GAAG,EAAG;AACnB,SAAK,IAAI,GAAG;AACZ,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;AAWO,SAAS,aACd,OACA,QACA,OACK;AACL,QAAM,QAAQ,SAAS,QAAQ,KAAK;AACpC,QAAM,2BAAW,IAAA;AACjB,QAAM,SAAc,CAAA;AACpB,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,QAAQ,MAAM,IAAI,IAAI;AAClC,QAAI,CAAC,MAAM,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,EAAG;AACtC,SAAK,IAAI,GAAG;AACZ,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;AAaO,SAAS,WACd,OACA,QACA,OACK;AACL,QAAM,QAAQ,SAAS,QAAQ,KAAK;AACpC,QAAM,2BAAW,IAAA;AACjB,QAAM,SAAc,CAAA;AACpB,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,QAAQ,MAAM,IAAI,IAAI;AAClC,QAAI,MAAM,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,EAAG;AACrC,SAAK,IAAI,GAAG;AACZ,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;AAWO,SAAS,oBACd,OACA,QACA,OACK;AACL,SAAO,CAAC,GAAG,WAAW,OAAO,QAAQ,KAAK,GAAG,GAAG,WAAW,QAAQ,OAAO,KAAK,CAAC;AAClF;ACrGO,SAAS,MACd,OACA,OACc;AACd,QAAM,6BAAa,IAAA;AACnB,QAAM,QAAQ,CAAC,MAAM,UAAU;AAC7B,WAAO,IAAI,MAAM,MAAM,KAAK,GAAG,IAAI;AAAA,EACrC,CAAC;AACD,SAAO;AACT;AAyBO,SAAS,UACd,QACA,OACiD;AACjD,MAAI,kBAAkB,KAAK;AACzB,UAAMA,8BAAa,IAAA;AACnB,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,WAAW;AAC3CA,cAAO,IAAI,KAAK,MAAM,OAAgB,GAAY,CAAC;AAAA,IACrD;AACA,WAAOA;AAAAA,EACT;AACA,QAAM,SAAS;AACf,QAAM,SAAkC,CAAA;AACxC,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,WAAO,GAAG,IAAI,MAAM,OAAO,GAAG,GAAY,GAAY;AAAA,EACxD;AACA,SAAO;AACT;AAaO,SAAS,SACd,QACA,MACe;AACf,QAAM,SAAS,CAAA;AACf,aAAW,OAAO,MAAM;AACtB,QAAI,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,EAAG,QAAO,GAAG,IAAI,OAAO,GAAG;AAAA,EACjF;AACA,SAAO;AACT;AAUO,SAAS,SACd,QACA,MACe;AACf,QAAM,UAAU,IAAI,IAAiB,IAAI;AACzC,QAAM,SAAS;AACf,QAAM,SAAkC,CAAA;AACxC,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,QAAI,CAAC,QAAQ,IAAI,GAAG,EAAG,QAAO,GAAG,IAAI,OAAO,GAAG;AAAA,EACjD;AACA,SAAO;AACT;AASO,SAAS,gBACd,SACsB;AACtB,QAAM,SAAS,CAAA;AACf,aAAW,CAAC,KAAK,KAAK,KAAK,QAAS,QAAO,GAAG,IAAI;AAClD,SAAO;AACT;AASO,SAAS,gBACd,QACuB;AACvB,QAAM,OAAO,OAAO,KAAK,MAAM;AAC/B,SAAO,KAAK,IAAI,CAAC,QAAQ,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC;AAC7C;AASO,SAAS,aACd,QACsB;AACtB,QAAM,SAAS,CAAA;AACf,aAAW,CAAC,KAAK,KAAK,KAAK,gBAAgB,MAAM,EAAG,QAAO,KAAK,IAAI;AACpE,SAAO;AACT;AC7HO,SAAS,kBAAqB,OAAqB,QAA+B;AACvF,MAAI,UAAU,OAAQ,QAAO;AAC7B,MAAI,MAAM,WAAW,OAAO,OAAQ,QAAO;AAC3C,SAAO,MAAM,MAAM,CAAC,MAAM,UAAU,OAAO,GAAG,MAAM,OAAO,KAAK,CAAC,CAAC;AACpE;AAaO,SAAS,aAAa,OAAgB,QAA0B;AACrE,MAAI,OAAO,GAAG,OAAO,MAAM,EAAG,QAAO;AACrC,MAAI,UAAU,QAAQ,WAAW,KAAM,QAAO;AAC9C,MAAI,OAAO,UAAU,YAAY,OAAO,WAAW,SAAU,QAAO;AACpE,MAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,QAAQ,MAAM,GAAG;AACjD,WAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,QAAQ,MAAM,KAAK,kBAAkB,OAAO,MAAM;AAAA,EACzF;AACA,SAAO,SAAS;AAAA,IACd;AAAA,IACA;AAAA,EAAA;AAEJ;AAgBO,SAAS,UAAU,OAAgB,QAA0B;AAClE,SAAO,gBAAgB,OAAO,QAAQ,oBAAI,KAA0B;AACtE;AAGA,SAAS,gBACP,OACA,QACA,MACS;AACT,MAAI,OAAO,GAAG,OAAO,MAAM,EAAG,QAAO;AACrC,MAAI,UAAU,QAAQ,WAAW,KAAM,QAAO;AAC9C,MAAI,OAAO,UAAU,YAAY,OAAO,WAAW,SAAU,QAAO;AAEpE,QAAM,WAAW,KAAK,IAAI,KAAK;AAC/B,MAAI,UAAU,IAAI,MAAM,EAAG,QAAO;AAClC,MAAI,SAAU,UAAS,IAAI,MAAM;AAAA,MAC5B,MAAK,IAAI,OAAO,oBAAI,IAAY,CAAC,MAAM,CAAC,CAAC;AAE9C,QAAM,UAAU,eAAe,OAAO,QAAQ,IAAI;AAElD,MAAI,CAAC,QAAS,MAAK,IAAI,KAAK,GAAG,OAAO,MAAM;AAC5C,SAAO;AACT;AAGA,SAAS,eAAe,OAAe,QAAgB,MAAyC;AAC9F,MAAI,iBAAiB,QAAQ,kBAAkB,MAAM;AACnD,WACE,iBAAiB,QACjB,kBAAkB,QAClB,OAAO,GAAG,MAAM,QAAA,GAAW,OAAO,QAAA,CAAS;AAAA,EAE/C;AACA,MAAI,iBAAiB,UAAU,kBAAkB,QAAQ;AACvD,WACE,iBAAiB,UACjB,kBAAkB,UAClB,MAAM,WAAW,OAAO,UACxB,MAAM,UAAU,OAAO;AAAA,EAE3B;AACA,MAAI,YAAY,OAAO,KAAK,KAAK,YAAY,OAAO,MAAM,GAAG;AAC3D,QAAI,CAAC,YAAY,OAAO,KAAK,KAAK,CAAC,YAAY,OAAO,MAAM,EAAG,QAAO;AACtE,QAAI,MAAM,gBAAgB,OAAO,YAAa,QAAO;AACrD,WAAO;AAAA,MACL,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;AAAA,MAC/D,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA,IAAA;AAAA,EAEtE;AACA,MAAI,iBAAiB,eAAe,kBAAkB,aAAa;AACjE,QAAI,EAAE,iBAAiB,gBAAgB,EAAE,kBAAkB,aAAc,QAAO;AAChF,WAAO,WAAW,IAAI,WAAW,KAAK,GAAG,IAAI,WAAW,MAAM,CAAC;AAAA,EACjE;AACA,MAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,QAAQ,MAAM,GAAG;AACjD,QAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,CAAC,MAAM,QAAQ,MAAM,EAAG,QAAO;AAC5D,QAAI,MAAM,WAAW,OAAO,OAAQ,QAAO;AAC3C,WAAO,MAAM,MAAM,CAAC,MAAM,UAAU,gBAAgB,MAAM,OAAO,KAAK,GAAG,IAAI,CAAC;AAAA,EAChF;AACA,MAAI,iBAAiB,OAAO,kBAAkB,KAAK;AACjD,QAAI,EAAE,iBAAiB,QAAQ,EAAE,kBAAkB,KAAM,QAAO;AAChE,QAAI,MAAM,SAAS,OAAO,KAAM,QAAO;AACvC,WAAO,UAAU,OAAO,QAAQ,IAAI;AAAA,EACtC;AACA,MAAI,iBAAiB,OAAO,kBAAkB,KAAK;AACjD,QAAI,EAAE,iBAAiB,QAAQ,EAAE,kBAAkB,KAAM,QAAO;AAChE,QAAI,MAAM,SAAS,OAAO,KAAM,QAAO;AACvC,WAAO,UAAU,OAAO,QAAQ,IAAI;AAAA,EACtC;AAEA,QAAM,WAAW,OAAO,KAAK,KAAK;AAClC,QAAM,YAAY,OAAO,KAAK,MAAM;AACpC,MAAI,SAAS,WAAW,UAAU,OAAQ,QAAO;AACjD,QAAM,OAAO;AACb,QAAM,QAAQ;AACd,SAAO,SAAS;AAAA,IACd,CAAC,QACC,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,KAChD,gBAAgB,KAAK,GAAG,GAAG,MAAM,GAAG,GAAG,IAAI;AAAA,EAAA;AAEjD;AAGA,SAAS,WAAW,OAAmB,QAA6B;AAClE,MAAI,MAAM,WAAW,OAAO,OAAQ,QAAO;AAC3C,WAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;AACpD,QAAI,MAAM,KAAK,MAAM,OAAO,KAAK,EAAG,QAAO;AAAA,EAC7C;AACA,SAAO;AACT;AAOA,SAAS,UACP,OACA,QACA,MACS;AACT,MAAI,cAAc;AAClB,aAAW,OAAO,MAAM,QAAQ;AAC9B,QAAI,CAAC,OAAO,IAAI,GAAG,GAAG;AACpB,oBAAc;AACd;AAAA,IACF;AAAA,EACF;AACA,MAAI,aAAa;AACf,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO;AAChC,UAAI,CAAC,gBAAgB,OAAO,OAAO,IAAI,GAAG,GAAG,IAAI,EAAG,QAAO;AAAA,IAC7D;AACA,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,CAAC,GAAG,OAAO,SAAS;AACtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO;AAChC,UAAM,QAAQ,UAAU;AAAA,MACtB,CAAC,UACC,gBAAgB,KAAK,MAAM,CAAC,GAAG,IAAI,KAAK,gBAAgB,OAAO,MAAM,CAAC,GAAG,IAAI;AAAA,IAAA;AAEjF,QAAI,UAAU,GAAI,QAAO;AACzB,cAAU,OAAO,OAAO,CAAC;AAAA,EAC3B;AACA,SAAO;AACT;AAMA,SAAS,UACP,OACA,QACA,MACS;AACT,QAAM,YAAuB,CAAA;AAC7B,aAAW,UAAU,OAAO;AAC1B,QAAI,CAAC,OAAO,IAAI,MAAM,EAAG,WAAU,KAAK,MAAM;AAAA,EAChD;AACA,MAAI,UAAU,WAAW,EAAG,QAAO;AAEnC,QAAM,aAAa,CAAC,GAAG,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,MAAM,IAAI,MAAM,CAAC;AACpE,MAAI,WAAW,WAAW,UAAU,OAAQ,QAAO;AACnD,aAAW,UAAU,WAAW;AAC9B,UAAM,QAAQ,WAAW,UAAU,CAAC,cAAc,gBAAgB,QAAQ,WAAW,IAAI,CAAC;AAC1F,QAAI,UAAU,GAAI,QAAO;AACzB,eAAW,OAAO,OAAO,CAAC;AAAA,EAC5B;AACA,SAAO;AACT;AC7KO,SAAS,UACd,OACA,SACe;AACf,QAAM,EAAE,IAAI,SAAA,IAAa;AAEzB,QAAM,2BAAW,IAAA;AACjB,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,GAAG,IAAI;AACnB,QAAI,CAAC,KAAK,IAAI,GAAG,EAAG,MAAK,IAAI,KAAK,IAAI;AAAA,EACxC;AAEA,QAAM,YAAY,gBAAgB,OAAO,MAAM,IAAI,QAAQ;AAE3D,QAAM,mCAAmB,IAAA;AACzB,QAAM,QAAa,CAAA;AACnB,aAAW,QAAQ,OAAO;AACxB,UAAM,SAAS,SAAS,IAAI;AAC5B,UAAM,SACJ,WAAW,QAAQ,WAAW,UAAa,CAAC,KAAK,IAAI,MAAM,KAAK,UAAU,IAAI,GAAG,IAAI,CAAC;AACxF,QAAI,QAAQ;AACV,YAAM,KAAK,IAAI;AACf;AAAA,IACF;AACA,UAAM,WAAW,aAAa,IAAI,MAAM;AACxC,QAAI,SAAU,UAAS,KAAK,IAAI;AAAA,QAC3B,cAAa,IAAI,QAAQ,CAAC,IAAI,CAAC;AAAA,EACtC;AAEA,QAAM,gCAAgB,IAAA;AACtB,QAAM,SAAS,CAAC,SAAyB;AACvC,UAAM,MAAM,GAAG,IAAI;AAGnB,QAAI,UAAU,IAAI,GAAG,UAAU,EAAE,MAAM,UAAU,GAAC;AAClD,cAAU,IAAI,GAAG;AACjB,UAAM,YAAY,aAAa,IAAI,GAAG,KAAK,CAAA,GAAI,IAAI,MAAM;AACzD,cAAU,OAAO,GAAG;AACpB,WAAO,EAAE,MAAM,SAAA;AAAA,EACjB;AAEA,SAAO,MAAM,IAAI,MAAM;AACzB;AAMA,SAAS,gBACP,OACA,MACA,IACA,UACU;AACV,QAAM,gCAAgB,IAAA;AACtB,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,GAAG,IAAI;AACrB,QAAI,UAAU,IAAI,KAAK,EAAG;AAE1B,UAAM,OAAc,CAAA;AACpB,UAAM,6BAAa,IAAA;AACnB,QAAI,YAA6B;AACjC,WAAO,cAAc,QAAW;AAC9B,UAAI,OAAO,IAAI,SAAS,GAAG;AAEzB,cAAM,YAAY,KAAK,QAAQ,SAAS;AACxC,iBAAS,QAAQ,WAAW,QAAQ,KAAK,QAAQ,SAAS,GAAG;AAC3D,oBAAU,IAAI,KAAK,KAAK,CAAQ;AAAA,QAClC;AACA;AAAA,MACF;AACA,YAAM,QAAQ,KAAK,IAAI,SAAS;AAChC,UAAI,UAAU,OAAW;AACzB,aAAO,IAAI,SAAS;AACpB,WAAK,KAAK,SAAS;AACnB,kBAAY,SAAS,KAAK,KAAK;AAAA,IACjC;AAAA,EACF;AACA,SAAO;AACT;AAGA,SAAS,aACP,MACA,aACkB;AAClB,QAAM,WAAY,KAAsC,WAAW;AACnE,SAAO,MAAM,QAAQ,QAAQ,IAAK,WAAuB,CAAA;AAC3D;AAYO,SAAS,YACd,OACA,cAA2B,YAClB;AACT,QAAM,SAAkB,CAAA;AACxB,QAAM,8BAAc,IAAA;AACpB,QAAM,OAAO,CAAC,UAAkC;AAC9C,eAAW,QAAQ,OAAO;AACxB,UAAI,QAAQ,IAAI,IAAI,EAAG;AACvB,cAAQ,IAAI,IAAI;AAChB,aAAO,KAAK,IAAI;AAChB,WAAK,aAAa,MAAM,WAAW,CAAC;AAAA,IACtC;AAAA,EACF;AACA,OAAK,KAAK;AACV,SAAO;AACT;AAWO,SAAS,WACd,OACA,WACA,cAA2B,YACR;AACnB,QAAM,8BAAc,IAAA;AACpB,QAAM,OAAO,CAAC,OAAyB,UAAqC;AAC1E,eAAW,QAAQ,OAAO;AACxB,UAAI,QAAQ,IAAI,IAAI,EAAG;AACvB,cAAQ,IAAI,IAAI;AAChB,UAAI,UAAU,MAAM,KAAK,EAAG,QAAO;AACnC,YAAM,QAAQ,KAAK,aAAa,MAAM,WAAW,GAAG,QAAQ,CAAC;AAC7D,UAAI,UAAU,OAAW,QAAO;AAAA,IAClC;AACA,WAAO;AAAA,EACT;AACA,SAAO,KAAK,OAAO,CAAC;AACtB;AAYO,SAAS,QACd,OACA,OACqB;AACrB,QAAM,OAAO,CAAC,OAA+B,UAC3C,MAAM,IAAI,CAAC,UAAU;AAAA,IACnB,MAAM,MAAM,KAAK,MAAM,KAAK;AAAA,IAC5B,UAAU,KAAK,KAAK,UAAU,QAAQ,CAAC;AAAA,EAAA,EACvC;AACJ,SAAO,KAAK,OAAO,CAAC;AACtB;"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/collections/Arrays.ts","../../../src/foundation/collections/SetOps.ts","../../../src/foundation/collections/Records.ts","../../../src/foundation/collections/Comparison.ts","../../../src/foundation/collections/Tree.ts"],"sourcesContent":["// Arrays — the immutable list operations every list-shaped surface re-derives: dedupe, group, split,\n// reorder, and the four positional edits (insert / remove / replace / toggle).\n//\n// WHY A SLICE AND NOT A DEPENDENCY. `lodash` / `remeda` cover most of this, but the SDK ships as a\n// peer-light package: one utility import must not pull a second collection library into every product\n// bundle. Each function here is a handful of lines and the behaviour is pinned by one test file.\n//\n// EVERY FUNCTION RETURNS A NEW ARRAY — including the no-op cases (`move(items, 2, 2)`,\n// `removeAt(items, 99)`). A conditional identity return is the classic reactivity footgun: a caller relying on\n// referential change to re-render would silently stop updating for exactly the inputs that look harmless.\n// The copy is O(n) and n here is a rendered list. (`selection`'s `applySort` deliberately makes the other\n// choice — it returns the input for an empty descriptor list — because an unsorted render is its hot path.)\n//\n// POSITIONAL EDITS CLAMP, THEY DO NOT THROW. Drag-and-drop, keyboard reorder, and server-echoed indices\n// all produce out-of-range values under normal operation; a thrown `RangeError` in a render path turns a\n// cosmetic bug into a blank screen. `chunk` and `range` are the exceptions and DO throw, because a zero or\n// negative step is a programmer error with no sane fallback — and would loop forever.\n\nimport { Equality, type EqualityComparer } from './Equality';\n\n/**\n * Removes duplicates, keeping the FIRST occurrence of each key and the input's order.\n *\n * Without `keyFn` the item itself is the key, compared with `Set` semantics (SameValueZero — so `NaN`\n * de-duplicates against `NaN`, and `+0` against `-0`). With `keyFn`, the extracted key decides, which is\n * how you de-duplicate rows by `id` while keeping the first-seen row object.\n *\n * @param items The source list; never mutated.\n * @param keyFn Optional key extractor receiving the item and its index.\n * @returns A new array holding the first item per distinct key.\n */\nexport function unique<T, TKey = T>(items: ReadonlyArray<T>, keyFn?: (item: T, index: number) => TKey): T[] {\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  items.forEach((item, index) => {\n    const key = keyFn ? keyFn(item, index) : item;\n    if (seen.has(key)) return;\n    seen.add(key);\n    result.push(item);\n  });\n  return result;\n}\n\n/**\n * Buckets items by an extracted key into a `Map`.\n *\n * A `Map` rather than a plain object for two reasons: keys stay their real type (a numeric or object key\n * is not stringified), and iteration order is the order keys were FIRST seen — a plain object reorders\n * integer-like keys ahead of string ones, which silently rearranges rendered group headings.\n *\n * @param items The source list; never mutated.\n * @param keyFn Extracts the group key from an item and its index.\n * @returns A new `Map` of key to a new array of that key's items, both in first-seen order.\n */\nexport function groupBy<T, TKey>(items: ReadonlyArray<T>, keyFn: (item: T, index: number) => TKey): Map<TKey, T[]> {\n  const groups = new Map<TKey, T[]>();\n  items.forEach((item, index) => {\n    const key = keyFn(item, index);\n    const group = groups.get(key);\n    if (group) group.push(item);\n    else groups.set(key, [item]);\n  });\n  return groups;\n}\n\n/**\n * Splits a list in two by a predicate, in one pass, preserving order in both halves.\n *\n * @param items The source list; never mutated.\n * @param predicate Decides whether an item belongs to the first half.\n * @returns A `[matched, rest]` tuple of two new arrays.\n */\nexport function partition<T>(items: ReadonlyArray<T>, predicate: (item: T, index: number) => boolean): [T[], T[]] {\n  const matched: T[] = [];\n  const rest: T[] = [];\n  items.forEach((item, index) => {\n    (predicate(item, index) ? matched : rest).push(item);\n  });\n  return [matched, rest];\n}\n\n/**\n * Slices a list into consecutive groups of at most `size`. The final group is short when the length is\n * not a multiple of `size`.\n *\n * @param items The source list; never mutated.\n * @param size The maximum group length; must be a positive integer.\n * @returns A new array of new arrays. An empty input yields `[]`, never `[[]]`.\n * @throws {RangeError} When `size` is not a positive integer — a zero or negative size has no meaningful\n * result and would loop forever.\n */\nexport function chunk<T>(items: ReadonlyArray<T>, size: number): T[][] {\n  if (!Number.isInteger(size) || size < 1) {\n    throw new RangeError(`chunk: size must be a positive integer, received ${String(size)}`);\n  }\n  const result: T[][] = [];\n  for (let index = 0; index < items.length; index += size) {\n    result.push(items.slice(index, index + size));\n  }\n  return result;\n}\n\n/**\n * Reorders one item, using drag-and-drop semantics: the item is REMOVED first, then re-inserted at `to`\n * measured in the shortened list. This is the behaviour a pointer drag implies — dropping item 0 onto\n * slot 2 of `[a, b, c, d]` yields `[b, c, a, d]`, i.e. the dragged item lands where the cursor is, not one\n * slot past it. Pairs with `foundation/gestures`' `useDrag`.\n *\n * Both indices are truncated and clamped into range, so an over-drag past either end parks the item at\n * that end instead of throwing or dropping it.\n *\n * @param items The source list; never mutated.\n * @param from The index of the item to move.\n * @param to The index it should occupy afterwards.\n * @returns A new array with the item relocated; a new copy when `from` and `to` resolve to the same slot.\n */\nexport function move<T>(items: ReadonlyArray<T>, from: number, to: number): T[] {\n  const result = [...items];\n  if (result.length === 0) return result;\n  const lastIndex = result.length - 1;\n  const fromIndex = Math.min(Math.max(Math.trunc(from), 0), lastIndex);\n  const toIndex = Math.min(Math.max(Math.trunc(to), 0), lastIndex);\n  if (fromIndex === toIndex) return result;\n  const [moved] = result.splice(fromIndex, 1);\n  result.splice(toIndex, 0, moved as T);\n  return result;\n}\n\n/**\n * Inserts one value at an index. The index is clamped to `[0, length]`, so `length` appends and a\n * negative index prepends.\n *\n * @param items The source list; never mutated.\n * @param index Where the new value should land.\n * @param value The value to insert.\n * @returns A new array one longer than the input.\n */\nexport function insertAt<T>(items: ReadonlyArray<T>, index: number, value: T): T[] {\n  const result = [...items];\n  const at = Math.min(Math.max(Math.trunc(index), 0), result.length);\n  result.splice(at, 0, value);\n  return result;\n}\n\n/**\n * Removes the item at an index. An out-of-range index removes nothing and still returns a fresh copy.\n *\n * @param items The source list; never mutated.\n * @param index The index to drop.\n * @returns A new array, one shorter when the index was in range.\n */\nexport function removeAt<T>(items: ReadonlyArray<T>, index: number): T[] {\n  const result = [...items];\n  const at = Math.trunc(index);\n  if (!Number.isFinite(at) || at < 0 || at >= result.length) return result;\n  result.splice(at, 1);\n  return result;\n}\n\n/**\n * Replaces the item at an index. An out-of-range index replaces nothing and still returns a fresh copy —\n * it never grows the array or punches an `undefined` hole in it.\n *\n * @param items The source list; never mutated.\n * @param index The index to overwrite.\n * @param value The replacement value.\n * @returns A new array of the same length as the input.\n */\nexport function replaceAt<T>(items: ReadonlyArray<T>, index: number, value: T): T[] {\n  const result = [...items];\n  const at = Math.trunc(index);\n  if (!Number.isFinite(at) || at < 0 || at >= result.length) return result;\n  result[at] = value;\n  return result;\n}\n\n/**\n * Adds an item when absent, removes it when present — the checkbox/chip/multi-select primitive.\n *\n * Equality defaults to `foundation/collections`' `Equality.strictEquals` (`Object.is`), which is reference\n * equality for objects; pass `Equality.byKey((row) => row.id)` (or any comparer) when the toggled value is\n * a fresh object each render. EVERY match is removed, so a list that already held duplicates toggles all of\n * them off at once. An added item is appended at the end.\n *\n * @param items The source list; never mutated.\n * @param item The value to toggle.\n * @param equalsFn Decides whether a list entry IS the toggled item.\n * @returns A new array with the item removed or appended.\n */\nexport function toggleItem<T>(\n  items: ReadonlyArray<T>,\n  item: T,\n  equalsFn: EqualityComparer<T> = Equality.strictEquals,\n): T[] {\n  const remaining = items.filter((candidate) => !equalsFn(candidate, item));\n  return remaining.length === items.length ? [...items, item] : remaining;\n}\n\n/**\n * Pairs two lists positionally, stopping at the SHORTER one — the extra tail is dropped rather than\n * padded with `undefined`, so the result type has no holes to narrow away at every call site.\n *\n * @param first The list supplying each pair's first slot.\n * @param second The list supplying each pair's second slot.\n * @returns A new array of `[first, second]` tuples, `min(first.length, second.length)` long.\n */\nexport function zip<TFirst, TSecond>(\n  first: ReadonlyArray<TFirst>,\n  second: ReadonlyArray<TSecond>,\n): Array<[TFirst, TSecond]> {\n  const length = Math.min(first.length, second.length);\n  const result: Array<[TFirst, TSecond]> = [];\n  for (let index = 0; index < length; index += 1) {\n    result.push([first[index] as TFirst, second[index] as TSecond]);\n  }\n  return result;\n}\n\n/**\n * Splits a list of pairs back into two lists — the inverse of {@link zip}.\n *\n * @param pairs The tuples to split.\n * @returns A `[firsts, seconds]` tuple of two new arrays, each as long as `pairs`.\n */\nexport function unzip<TFirst, TSecond>(pairs: readonly (readonly [TFirst, TSecond])[]): [TFirst[], TSecond[]] {\n  const first: TFirst[] = [];\n  const second: TSecond[] = [];\n  for (const pair of pairs) {\n    first.push(pair[0]);\n    second.push(pair[1]);\n  }\n  return [first, second];\n}\n\n/**\n * Builds a numeric sequence over the HALF-OPEN interval `[start, end)` — `end` is excluded, so\n * `range(0, items.length)` indexes a list exactly and `range(a, b).length === b - a`.\n *\n * A negative `step` counts down. When the step points away from `end` (`range(0, 5, -1)`) the result is\n * empty rather than infinite.\n *\n * @param start The first value, always included when the range is non-empty.\n * @param end The exclusive bound.\n * @param step The increment; defaults to `1`.\n * @returns A new array of numbers.\n * @throws {RangeError} When `step` is zero or any argument is non-finite — each would loop forever.\n */\nexport function range(start: number, end: number, step = 1): number[] {\n  if (!Number.isFinite(start) || !Number.isFinite(end)) {\n    throw new RangeError(`range: start and end must be finite, received ${String(start)}..${String(end)}`);\n  }\n  if (step === 0 || !Number.isFinite(step)) {\n    throw new RangeError(`range: step must be a non-zero finite number, received ${String(step)}`);\n  }\n  const result: number[] = [];\n  for (let value = start; step > 0 ? value < end : value > end;) {\n    result.push(value);\n    const next = value + step;\n    if (next === value) throw new RangeError('range: step cannot advance at this magnitude.');\n    value = next;\n  }\n  return result;\n}\n","// SetOps — the four set relations, expressed over ARRAYS rather than `Set`s.\n//\n// WHY ARRAYS IN AND ARRAYS OUT. A `Set` is the right internal index and the wrong public type here: `v-for`\n// renders lists, `key` bindings need a stable order, and a `Set` has no index. Every caller that reached for\n// `new Set([...a].filter(...))` had to spread it straight back to an array anyway, losing order on the way.\n// These take arrays, index with a `Set` internally, and hand back arrays.\n//\n// ORDER IS DEFINED, NOT INCIDENTAL. Results follow the FIRST argument's order, then (for `union` and\n// `symmetricDifference`) the second's. Set theory says these are unordered; a rendered list disagrees, and\n// an undefined order would reshuffle rows on every recompute.\n//\n// SET SEMANTICS MEAN DE-DUPLICATION. All four collapse duplicates within the inputs — `union([a, a], [])`\n// is `[a]`. Use `foundation/collections`' `Arrays` helpers when you want a bag, not a set.\n//\n// The optional `keyFn` is what makes these usable on entities: two fetches return equal-but-not-identical\n// row objects, so `difference(next, previous, (row) => row.id)` is the real-world call, not the identity one.\n\n/** Indexes a list by its comparison key — the shared internal step of every relation below. */\nfunction toKeySet<T, TKey>(items: ReadonlyArray<T>, keyFn?: (item: T) => TKey): Set<TKey | T> {\n  const keys = new Set<TKey | T>();\n  for (const item of items) keys.add(keyFn ? keyFn(item) : item);\n  return keys;\n}\n\n/**\n * Everything in either list, de-duplicated by key.\n *\n * Order is all of `first` followed by the members of `second` not already present. When two items share a\n * key, the one from `first` is the one kept — the left list wins, which is what an \"apply these updates on\n * top of what I have\" call expects.\n *\n * @param first The list whose items and order take precedence.\n * @param second The list contributing anything new.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function union<T, TKey = T>(first: ReadonlyArray<T>, second: ReadonlyArray<T>, keyFn?: (item: T) => TKey): T[] {\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  for (const item of first) {\n    const key = keyFn ? keyFn(item) : item;\n    if (seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  for (const item of second) {\n    const key = keyFn ? keyFn(item) : item;\n    if (seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  return result;\n}\n\n/**\n * Only the items whose key appears in BOTH lists, de-duplicated, in `first`'s order and holding `first`'s\n * item instances.\n *\n * @param first The list supplying the result's items and order.\n * @param second The list acting as the membership test.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function intersection<T, TKey = T>(\n  first: ReadonlyArray<T>,\n  second: ReadonlyArray<T>,\n  keyFn?: (item: T) => TKey,\n): T[] {\n  const other = toKeySet(second, keyFn);\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  for (const item of first) {\n    const key = keyFn ? keyFn(item) : item;\n    if (!other.has(key) || seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  return result;\n}\n\n/**\n * The items of `first` whose key does NOT appear in `second`, de-duplicated, in `first`'s order.\n *\n * Asymmetric by definition: `difference(a, b)` answers \"what did I gain\", `difference(b, a)` answers \"what\n * did I lose\".\n *\n * @param first The list to subtract from.\n * @param second The list to subtract.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function difference<T, TKey = T>(\n  first: ReadonlyArray<T>,\n  second: ReadonlyArray<T>,\n  keyFn?: (item: T) => TKey,\n): T[] {\n  const other = toKeySet(second, keyFn);\n  const seen = new Set<TKey | T>();\n  const result: T[] = [];\n  for (const item of first) {\n    const key = keyFn ? keyFn(item) : item;\n    if (other.has(key) || seen.has(key)) continue;\n    seen.add(key);\n    result.push(item);\n  }\n  return result;\n}\n\n/**\n * Everything present in exactly one of the two lists — the \"what changed\" relation, `first`-only entries\n * followed by `second`-only entries.\n *\n * @param first The left list.\n * @param second The right list.\n * @param keyFn Optional key extractor; defaults to the item itself (SameValueZero).\n * @returns A new array; neither input is mutated.\n */\nexport function symmetricDifference<T, TKey = T>(\n  first: ReadonlyArray<T>,\n  second: ReadonlyArray<T>,\n  keyFn?: (item: T) => TKey,\n): T[] {\n  return [...difference(first, second, keyFn), ...difference(second, first, keyFn)];\n}\n","// Records — the keyed-collection half of the slice: turning a list into a lookup, and reshaping the\n// lookup without mutating it.\n//\n// MAP FOR DERIVED LOOKUPS, RECORD FOR DECLARED SHAPES. `keyBy` returns a `Map` because the key comes from\n// the data at runtime and may be any type — a plain object would stringify a numeric id and reorder\n// integer-like keys ahead of string ones. `pickKeys` / `omitKeys` / `invertRecord` take records because\n// their keys are part of the caller's declared type, and the return type is derived from it (`Pick` /\n// `Omit`), which is the whole reason to prefer them over hand-written destructuring.\n//\n// `mapValues` straddles the two on purpose: it is overloaded so `groupBy(...)` → `mapValues(groups, (rows)\n// => rows.length)` keeps its `Map`, while a config record stays a record. One name, because the intent is\n// identical and a caller should not have to remember which container they are holding.\n//\n// STRING KEYS ONLY on the record helpers. They walk `Object.keys`, so own enumerable STRING keys are\n// visited: symbol keys are skipped, and a numeric key comes back as its string form (JavaScript's rule,\n// not this slice's). Prototype-inherited properties are never copied.\n\n/**\n * Indexes a list by an extracted key. The LAST item wins on a duplicate key, matching the \"latest write\n * of this id\" reading a lookup usually wants — use {@link groupBy} instead when duplicates are meaningful.\n *\n * @param items The source list; never mutated.\n * @param keyFn Extracts an item's key from the item and its index.\n * @returns A new `Map` in first-seen key order.\n * @see groupBy — the same shape when a key can legitimately hold several items.\n */\nexport function keyBy<T, TKey>(items: ReadonlyArray<T>, keyFn: (item: T, index: number) => TKey): Map<TKey, T> {\n  const result = new Map<TKey, T>();\n  items.forEach((item, index) => {\n    result.set(keyFn(item, index), item);\n  });\n  return result;\n}\n\n/**\n * Transforms every value, keeping the keys and their order. Overloaded on the container: a `Map` in gives\n * a `Map` out, a record in gives a record out.\n *\n * @param source The `Map` whose values should be transformed; never mutated.\n * @param mapFn Produces the replacement value from the current value and its key.\n * @returns A new `Map` with the same keys in the same order.\n */\nexport function mapValues<TKey, TValue, TResult>(\n  source: ReadonlyMap<TKey, TValue>,\n  mapFn: (value: TValue, key: TKey) => TResult,\n): Map<TKey, TResult>;\n/**\n * Transforms every value, keeping the keys and their order.\n *\n * @param source The record whose values should be transformed; never mutated.\n * @param mapFn Produces the replacement value from the current value and its key.\n * @returns A new record with the same own enumerable string keys.\n */\nexport function mapValues<TKey extends PropertyKey, TValue, TResult>(\n  source: Readonly<Record<TKey, TValue>>,\n  mapFn: (value: TValue, key: TKey) => TResult,\n): Record<TKey, TResult>;\nexport function mapValues(\n  source: ReadonlyMap<unknown, unknown> | object,\n  mapFn: (value: never, key: never) => unknown,\n): Map<unknown, unknown> | Record<string, unknown> {\n  if (source instanceof Map) {\n    const mapped = new Map<unknown, unknown>();\n    for (const [key, value] of source.entries()) {\n      mapped.set(key, mapFn(value as never, key as never));\n    }\n    return mapped;\n  }\n  const record = source as Record<string, unknown>;\n  const mapped: Record<string, unknown> = {};\n  for (const key of Object.keys(record)) {\n    defineEntry(mapped, key, mapFn(record[key] as never, key as never));\n  }\n  return mapped;\n}\n\n/**\n * Copies only the named keys into a new object.\n *\n * A key the source does not actually own is SKIPPED rather than copied as `undefined` — otherwise\n * `pickKeys(partial, ['a', 'b'])` would fabricate a `b` property that fails a `'b' in result` check and\n * serialises as an explicit null in a request body.\n *\n * @param source The object to read from; never mutated.\n * @param keys The keys to keep.\n * @returns A new object holding only the present named keys.\n */\nexport function pickKeys<T extends object, TKey extends keyof T>(source: T, keys: ReadonlyArray<TKey>): Pick<T, TKey> {\n  const result = {} as Pick<T, TKey>;\n  for (const key of keys) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) defineEntry(result, key, source[key]);\n  }\n  return result;\n}\n\n/**\n * Copies every own enumerable string key EXCEPT the named ones into a new object — the immutable spelling\n * of `delete`, and the typed one (the result type loses the removed keys).\n *\n * @param source The object to read from; never mutated.\n * @param keys The keys to drop.\n * @returns A new object without the named keys.\n */\nexport function omitKeys<T extends object, TKey extends keyof T>(source: T, keys: ReadonlyArray<TKey>): Omit<T, TKey> {\n  const omitted = new Set<PropertyKey>(keys);\n  const record = source as Record<string, unknown>;\n  const result: Record<string, unknown> = {};\n  for (const key of Object.keys(record)) {\n    if (!omitted.has(key)) defineEntry(result, key, record[key]);\n  }\n  return result as Omit<T, TKey>;\n}\n\n/**\n * Collects key/value pairs into a record. Accepts any iterable, so a `Map`, a `URLSearchParams`, or the\n * output of {@link recordToEntries} all feed it directly. The LAST pair wins on a duplicate key.\n *\n * @param entries The pairs to collect.\n * @returns A new record.\n */\nexport function entriesToRecord<TKey extends PropertyKey, TValue>(\n  entries: Iterable<readonly [TKey, TValue]>,\n): Record<TKey, TValue> {\n  const result = {} as Record<TKey, TValue>;\n  for (const [key, value] of entries) defineEntry(result, key, value);\n  return result;\n}\n\n/**\n * Lists a record's own enumerable string keys with their values, in `Object.keys` order — the typed\n * counterpart to `Object.entries`, which widens every key to `string`.\n *\n * @param record The record to read; never mutated.\n * @returns A new array of `[key, value]` tuples.\n */\nexport function recordToEntries<TKey extends PropertyKey, TValue>(\n  record: Readonly<Record<TKey, TValue>>,\n): Array<[TKey, TValue]> {\n  const keys = Object.keys(record) as Array<TKey & string>;\n  return keys.map((key) => [key, record[key]]);\n}\n\n/**\n * Swaps keys and values. The LAST key wins when two keys share a value, so inverting a non-injective\n * record is lossy by design — the alternative (an array of keys per value) is {@link groupBy}'s job.\n *\n * @param record The record to invert; never mutated.\n * @returns A new record mapping each value back to a key.\n */\nexport function invertRecord<TKey extends PropertyKey, TValue extends PropertyKey>(\n  record: Readonly<Record<TKey, TValue>>,\n): Record<TValue, TKey> {\n  const result = {} as Record<TValue, TKey>;\n  for (const [key, value] of recordToEntries(record)) defineEntry(result, value, key);\n  return result;\n}\n\n/** Defines data without invoking Object.prototype's legacy __proto__ setter. */\nfunction defineEntry(target: object, key: PropertyKey, value: unknown): void {\n  Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });\n}\n","// Comparison — structural equality for memo boundaries: `v-memo`, `computed` guards, \"is this form\n// dirty\", \"did the server actually send something new\".\n//\n// THREE FUNCTIONS, THREE COSTS, PICK DELIBERATELY. `arrayShallowEqual` is O(n) reference checks and is\n// what a list-prop memo wants. `shallowEqual` is the same one level deep on either arrays or objects.\n// `deepEqual` walks the whole structure — correct, and the one you must not put on a hot path over a large\n// payload without meaning to.\n//\n// `shallowEqual` DELEGATES its plain-object case to `foundation/collections`' `Equality.shallowEquals` rather\n// than re-deriving it; this file only adds the array dispatch and the deep walk, which that helper\n// deliberately does not do.\n//\n// WHY A DEEP VARIANT LIVES HERE AT ALL. `forms-engine` already carries a local `deepEqual`, scoped to form\n// values (primitives, plain objects, arrays, `Date`, `File`/`Blob`) and reachable only from that layer —\n// `foundation` may not import upward. This one is the general one: it additionally handles `Map`, `Set`,\n// `RegExp`, `ArrayBuffer` and typed arrays, and it terminates on circular structures.\n//\n// CIRCULARITY IS CO-INDUCTIVE. A pair already being compared higher in the stack is ASSUMED equal, so two\n// structures that loop the same way compare equal instead of recursing forever — the standard rule, and\n// the only one that terminates. The in-progress pair is dropped again when a comparison fails, because the\n// `Map`/`Set` matchers below probe candidate pairs whose failure must not be remembered as a success.\n//\n// TYPED ARRAYS COMPARE BYTE-WISE (same constructor, same byte length, same bytes). One consequence worth\n// knowing: `+0` and `-0` differ in bits, so they compare UNEQUAL inside a `Float64Array` while comparing\n// equal as plain numbers. Bit-equality is the right reading for a buffer.\n\nimport { Equality } from './Equality';\nimport { ExactNumber } from '../numbers';\n\n/**\n * Compares two arrays element-by-element with `Object.is` — no recursion, no allocation.\n *\n * The cheapest correct check for a list prop rebuilt each render from stable item references (a `.map()`\n * over cached rows, a `computed` dependency). `NaN` equals `NaN`; two structurally identical but distinct\n * objects do not.\n *\n * @param first The left array.\n * @param second The right array.\n * @returns `true` when both have the same length and every index holds the same value.\n */\nexport function arrayShallowEqual<T>(first: ReadonlyArray<T>, second: ReadonlyArray<T>): boolean {\n  if (first === second) return true;\n  if (first.length !== second.length) return false;\n  for (let index = 0; index < first.length; index++) {\n    if (!Object.is(first[index], second[index])) return false;\n  }\n  return true;\n}\n\n/**\n * Compares two values one level deep.\n *\n * Dispatches on shape: identical values short-circuit, two arrays go to {@link arrayShallowEqual}, two\n * objects compare their own enumerable keys with `Object.is`, and anything else (a primitive pair that was\n * not already identical, or a mismatched pair such as array vs object) is unequal.\n *\n * @param first The left value.\n * @param second The right value.\n * @returns `true` when the two are equal at one level of depth.\n */\nexport function shallowEqual(first: unknown, second: unknown): boolean {\n  if (Object.is(first, second)) return true;\n  if (first === null || second === null) return false;\n  if (typeof first !== 'object' || typeof second !== 'object') return false;\n  if (Array.isArray(first) || Array.isArray(second)) {\n    return Array.isArray(first) && Array.isArray(second) && arrayShallowEqual(first, second);\n  }\n  return Equality.shallowEquals(first as Record<string, unknown>, second as Record<string, unknown>);\n}\n\n/**\n * Compares two values structurally, all the way down.\n *\n * Understands `Date` (by timestamp), `RegExp` (source + flags), `Array`, `Map`, `Set`, `ArrayBuffer` and\n * every typed array / `DataView` (byte-wise), and plain objects (own enumerable string keys). `NaN` equals\n * `NaN`. Anything else falls back to `Object.is`, so two distinct `class` instances with equal fields DO\n * compare equal — the walk is structural and does not check constructors outside the built-ins above.\n *\n * Terminates on circular structures: a pair already under comparison is treated as equal.\n *\n * @param first The left value.\n * @param second The right value.\n * @returns `true` when the two are structurally equal.\n */\nexport function deepEqual(first: unknown, second: unknown): boolean {\n  return deepEqualWithin(first, second, new Map<object, Set<object>>());\n}\n\n/** Runs one comparison against the set of pairs already under comparison on this walk. */\nfunction deepEqualWithin(first: unknown, second: unknown, seen: Map<object, Set<object>>): boolean {\n  if (Object.is(first, second)) return true;\n  if (first === null || second === null) return false;\n  if (typeof first !== 'object' || typeof second !== 'object') return false;\n  if (ExactNumber.isExactNumber(first) || ExactNumber.isExactNumber(second)) {\n    return Equality.shallowEquals(first as Record<string, unknown>, second as Record<string, unknown>);\n  }\n\n  const partners = seen.get(first);\n  if (partners?.has(second)) return true;\n  if (partners) partners.add(second);\n  else seen.set(first, new Set<object>([second]));\n\n  const isEqual = compareObjects(first, second, seen);\n  // A failed probe must not linger as a remembered success — see the header note on `Map`/`Set` matching.\n  if (!isEqual) seen.get(first)?.delete(second);\n  return isEqual;\n}\n\n/** Dispatches two non-null objects to the branch that matches their built-in type. */\nfunction compareObjects(first: object, second: object, seen: Map<object, Set<object>>): boolean {\n  if (first instanceof Date || second instanceof Date) {\n    return first instanceof Date && second instanceof Date && Object.is(first.getTime(), second.getTime());\n  }\n  if (first instanceof RegExp || second instanceof RegExp) {\n    return (\n      first instanceof RegExp &&\n      second instanceof RegExp &&\n      first.source === second.source &&\n      first.flags === second.flags\n    );\n  }\n  if (ArrayBuffer.isView(first) || ArrayBuffer.isView(second)) {\n    if (!ArrayBuffer.isView(first) || !ArrayBuffer.isView(second)) return false;\n    if (first.constructor !== second.constructor) return false;\n    return bytesEqual(\n      new Uint8Array(first.buffer, first.byteOffset, first.byteLength),\n      new Uint8Array(second.buffer, second.byteOffset, second.byteLength),\n    );\n  }\n  if (first instanceof ArrayBuffer || second instanceof ArrayBuffer) {\n    if (!(first instanceof ArrayBuffer) || !(second instanceof ArrayBuffer)) return false;\n    return bytesEqual(new Uint8Array(first), new Uint8Array(second));\n  }\n  if (Array.isArray(first) || Array.isArray(second)) {\n    if (!Array.isArray(first) || !Array.isArray(second)) return false;\n    if (first.length !== second.length) return false;\n    for (let index = 0; index < first.length; index++) {\n      if (!deepEqualWithin(first[index], second[index], seen)) return false;\n    }\n    return true;\n  }\n  if (first instanceof Map || second instanceof Map) {\n    if (!(first instanceof Map) || !(second instanceof Map)) return false;\n    if (first.size !== second.size) return false;\n    return mapsEqual(first, second, seen);\n  }\n  if (first instanceof Set || second instanceof Set) {\n    if (!(first instanceof Set) || !(second instanceof Set)) return false;\n    if (first.size !== second.size) return false;\n    return setsEqual(first, second, seen);\n  }\n\n  const leftKeys = Object.keys(first);\n  const rightKeys = Object.keys(second);\n  if (leftKeys.length !== rightKeys.length) return false;\n  const left = first as Record<string, unknown>;\n  const right = second as Record<string, unknown>;\n  return leftKeys.every(\n    (key) => Object.prototype.hasOwnProperty.call(second, key) && deepEqualWithin(left[key], right[key], seen),\n  );\n}\n\n/** Compares two byte views of equal-or-different length. */\nfunction bytesEqual(first: Uint8Array, second: Uint8Array): boolean {\n  if (first.length !== second.length) return false;\n  for (let index = 0; index < first.length; index += 1) {\n    if (first[index] !== second[index]) return false;\n  }\n  return true;\n}\n\n/**\n * Compares two equally-sized maps. Takes the direct route when every key of `first` is a key of `second`\n * (the string/number-key case, O(n)); otherwise falls back to matching each entry against an unclaimed\n * entry of `second`, which is the only correct answer when keys are themselves objects.\n */\nfunction mapsEqual(\n  first: ReadonlyMap<unknown, unknown>,\n  second: ReadonlyMap<unknown, unknown>,\n  seen: Map<object, Set<object>>,\n): boolean {\n  let hasEveryKey = true;\n  for (const key of first.keys()) {\n    if (!second.has(key)) {\n      hasEveryKey = false;\n      break;\n    }\n  }\n  if (hasEveryKey) {\n    for (const [key, value] of first) {\n      if (!deepEqualWithin(value, second.get(key), seen)) return false;\n    }\n    return true;\n  }\n\n  const unclaimed = [...second.entries()];\n  for (const [key, value] of first) {\n    const index = unclaimed.findIndex(\n      (entry) => deepEqualWithin(key, entry[0], seen) && deepEqualWithin(value, entry[1], seen),\n    );\n    if (index === -1) return false;\n    unclaimed.splice(index, 1);\n  }\n  return true;\n}\n\n/**\n * Compares two equally-sized sets. Members present in both by identity are settled first and cost nothing;\n * only the structural leftovers are matched pairwise.\n */\nfunction setsEqual(first: ReadonlySet<unknown>, second: ReadonlySet<unknown>, seen: Map<object, Set<object>>): boolean {\n  const unmatched: unknown[] = [];\n  for (const member of first) {\n    if (!second.has(member)) unmatched.push(member);\n  }\n  if (unmatched.length === 0) return true;\n\n  const candidates = [...second].filter((member) => !first.has(member));\n  if (candidates.length !== unmatched.length) return false;\n  for (const member of unmatched) {\n    const index = candidates.findIndex((candidate) => deepEqualWithin(member, candidate, seen));\n    if (index === -1) return false;\n    candidates.splice(index, 1);\n  }\n  return true;\n}\n","// Tree — turning the flat `{ id, parentId }` list an API returns into something a tree view can render,\n// and walking it once it is nested.\n//\n// THE OUTPUT WRAPS, IT DOES NOT SPREAD. `buildTree` returns `TreeNode<T>` — `{ item, children }` — rather\n// than `{ ...item, children }`. Spreading copies every row (wasteful on a large list), breaks referential\n// equality against the source rows (so every memo downstream misses), and collides the moment a row has\n// its own `children` field. The wrapper holds the ORIGINAL item reference.\n//\n// SERVER DATA IS NOT A TREE UNTIL PROVEN. Two malformed shapes arrive in practice and neither may throw or\n// hang, because the alternative is a blank screen for one bad row:\n//\n//   1. ORPHAN — `parentId` names a row that is not in the list (deleted, or filtered out by paging). The\n//      orphan is PROMOTED TO A ROOT. Dropping it would silently hide data; a root is visible and wrong in\n//      a way a user can report.\n//   2. CYCLE — a parent chain that loops (`a → b → c → a`, or a row that is its own parent). Every row ON\n//      the cycle is PROMOTED TO A ROOT and its upward link is severed. Rows merely BELOW a cycle keep\n//      their parent and nest normally under whichever cycle member became a root. Nothing is dropped and\n//      every row appears exactly once. Detection visits each parent edge once, so building is O(n).\n//\n// Duplicate ids resolve to the first owner. Every input row has exactly one output node.\n//\n// `flattenTree` / `findInTree` take a `childrenKey` because a consumer's own nested shape (`items`,\n// `nodes`, `subRows`) is as common as this slice's own, and both guard against a self-referential node so\n// a hand-built structure cannot hang them either.\n\n/** One node of a built tree — the source item plus the items that named it as parent. */\nexport interface TreeNode<T> {\n  /** The source item, by reference — never a copy, so memo comparisons against the input still hit. */\n  readonly item: T;\n  /** The direct children, in the order the source list listed them. Empty for a leaf. */\n  readonly children: ReadonlyArray<TreeNode<T>>;\n}\n\n/** The two accessors {@link buildTree} needs to read a flat list's parent/child relation. */\nexport interface BuildTreeOptions<T, TId> {\n  /** Reads an item's own identity. */\n  readonly id: (item: T) => TId;\n  /** Reads the id of an item's parent, or a nullish value when the item is a root. */\n  readonly parentId: (item: T) => TId | null | undefined;\n}\n\n/**\n * Nests a flat list into roots-with-children.\n *\n * Root order and sibling order both follow the input's order — no sorting happens here, deliberately.\n * Ordering a tree is `foundation/selection`'s job (`applySort` over the flat list before building, or over\n * a node's `children` after); a second comparator in this slice would let a tree order its rows\n * differently from the table beside it.\n *\n * Malformed input is tolerated, not rejected: an item whose parent is missing becomes a root, and an item\n * on a cyclic parent chain becomes a root with its upward link severed. Neither case drops an item, and\n * neither hangs. A duplicate id resolves to its first occurrence for parent lookups.\n *\n * @param items The flat list; never mutated, and its item references are reused in the result.\n * @param options The `id` / `parentId` accessors.\n * @returns A new array of root nodes.\n */\nexport function buildTree<T, TId>(items: ReadonlyArray<T>, options: BuildTreeOptions<T, TId>): TreeNode<T>[] {\n  const byId = new Map<TId, number>();\n  const nodes = items.map((item, index) => {\n    const key = options.id(item);\n    if (!byId.has(key)) byId.set(key, index);\n    return { item, children: [] as TreeNode<T>[] };\n  });\n  const parents = items.map((item) => {\n    const key = options.parentId(item);\n    return key === null || key === undefined ? undefined : byId.get(key);\n  });\n  // Each parent edge is visited once. A completed chain never needs walking again.\n  const completed = new Set<number>();\n  const cyclic = new Set<number>();\n  for (let index = 0; index < nodes.length; index++) {\n    const path: number[] = [];\n    const positions = new Map<number, number>();\n    let current: number | undefined = index;\n    while (current !== undefined && !completed.has(current)) {\n      const position = positions.get(current);\n      if (position !== undefined) {\n        for (let offset = position; offset < path.length; offset++) cyclic.add(path[offset]!);\n        break;\n      }\n      positions.set(current, path.length);\n      path.push(current);\n      current = parents[current];\n    }\n    for (const visited of path) completed.add(visited);\n  }\n  const roots: TreeNode<T>[] = [];\n  nodes.forEach((node, index) => {\n    const parent = parents[index];\n    if (parent === undefined || cyclic.has(index)) roots.push(node);\n    else nodes[parent]!.children.push(node);\n  });\n  return roots;\n}\n\n/** Reads a node's children under the configured key, treating anything non-array as \"no children\". */\nfunction readChildren<TNode extends object>(node: TNode, childrenKey: PropertyKey): ReadonlyArray<TNode> {\n  const children = (node as Record<PropertyKey, unknown>)[childrenKey];\n  return Array.isArray(children) ? (children as TNode[]) : [];\n}\n\n/**\n * Walks a nested structure depth-first, pre-order, into one flat list — parent before its children, which\n * is the order a collapsed/expanded tree view renders rows in.\n *\n * A node already visited is skipped, so a self-referential structure terminates and each node appears once.\n *\n * @param nodes The roots to walk; never mutated, and node references are reused in the result.\n * @param childrenKey The property holding a node's children; defaults to `'children'`.\n * @returns A new flat array of the same node objects.\n */\nexport function flattenTree<TNode extends object>(\n  nodes: ReadonlyArray<TNode>,\n  childrenKey: PropertyKey = 'children',\n): TNode[] {\n  const result: TNode[] = [];\n  findInTree(\n    nodes,\n    (node) => {\n      result.push(node);\n      return false;\n    },\n    childrenKey,\n  );\n  return result;\n}\n\n/**\n * Finds the first node matching a predicate, depth-first, pre-order — the lookup behind \"select the node\n * for this route\" and \"reveal the row with this id\".\n *\n * @param nodes The roots to search.\n * @param predicate Receives each node and its 0-based depth.\n * @param childrenKey The property holding a node's children; defaults to `'children'`.\n * @returns The matching node, or `undefined` when nothing matches.\n */\nexport function findInTree<TNode extends object>(\n  nodes: ReadonlyArray<TNode>,\n  predicate: (node: TNode, depth: number) => boolean,\n  childrenKey: PropertyKey = 'children',\n): TNode | undefined {\n  const visited = new Set<TNode>();\n  const stack = [{ nodes, index: 0 }];\n  while (stack.length > 0) {\n    const frame = stack[stack.length - 1]!;\n    if (frame.index >= frame.nodes.length) {\n      stack.pop();\n      continue;\n    }\n    const node = frame.nodes[frame.index++]!;\n    if (visited.has(node)) continue;\n    visited.add(node);\n    if (predicate(node, stack.length - 1)) return node;\n    stack.push({ nodes: readChildren(node, childrenKey), index: 0 });\n  }\n  return undefined;\n}\n\n/**\n * Rebuilds a {@link TreeNode} tree with every item transformed, keeping the shape and the order.\n *\n * Typed to this slice's node shape rather than a `childrenKey`, because the result has to BE a tree: a\n * generic nested object could not be reassembled without knowing which key to write back.\n *\n * @param nodes The roots to map; never mutated.\n * @param mapFn Produces the replacement item from the current item and its 0-based depth.\n * @returns A new tree of new nodes.\n * @throws {TypeError} When the input contains a cycle; shared subtrees remain supported.\n */\nexport function mapTree<T, TResult>(\n  nodes: ReadonlyArray<TreeNode<T>>,\n  mapFn: (item: T, depth: number) => TResult,\n): TreeNode<TResult>[] {\n  const result: TreeNode<TResult>[] = [];\n  const active = new Set<TreeNode<T>>();\n  const stack: Array<{\n    nodes: ReadonlyArray<TreeNode<T>>;\n    index: number;\n    output: TreeNode<TResult>[];\n    owner?: TreeNode<T>;\n  }> = [{ nodes, index: 0, output: result }];\n  while (stack.length > 0) {\n    const frame = stack[stack.length - 1]!;\n    if (frame.index >= frame.nodes.length) {\n      if (frame.owner) active.delete(frame.owner);\n      stack.pop();\n      continue;\n    }\n    const node = frame.nodes[frame.index++]!;\n    if (active.has(node)) throw new TypeError('mapTree: cyclic input is not a tree.');\n    const children: TreeNode<TResult>[] = [];\n    frame.output.push({ item: mapFn(node.item, stack.length - 1), children });\n    active.add(node);\n    stack.push({ nodes: node.children, index: 0, output: children, owner: node });\n  }\n  return result;\n}\n"],"names":["mapped"],"mappings":"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"}

package/dist/foundation/commands/Command.d.ts

@@ -1,3 +1,4 @@
+import { Result } from '../results';
 /** The opaque payload handed to a command's `run` — apps narrow it inside their own handler (`ctx as MyCtx`). */
 export type CommandContext = unknown;
 /** Describes one invocable action — the unit a palette lists, a menu renders, and a chord triggers. */
@@ -11,36 +12,27 @@ export interface Command {
     /** Optional grouping label (`Navigation`, `Editor`) — used for section headers and searched at the lowest rank. */
     readonly group?: string;
     /** Extra search terms that don't belong in the title (`['theme', 'appearance']` for "Toggle dark mode"). */
-    readonly keywords?: readonly string[];
-    /** Optional chord string in `foundation/shortcuts` syntax (`'mod+k'`) — bound by `useCommandShortcuts`, rendered by `commandShortcutLabel`. */
+    readonly keywords?: ReadonlyArray<string>;
+    /**
+     * Optional chord string in `foundation/shortcuts` syntax (`'mod+k'`) — bound by `useCommandShortcuts`,
+     * rendered by `commandShortcutLabel`.
+     */
     readonly shortcut?: string;
-    /** Optional icon slot, intentionally untyped — foundation must not name a Vue icon component type. The render site casts. */
+    /** Optional icon slot, intentionally untyped — the render site casts it to its icon component type. */
     readonly icon?: unknown;
-    /** Availability predicate re-evaluated on every read. Must be cheap and side-effect free (`available()` calls it per command). */
+    /**
+     * Availability predicate re-evaluated on every read. Must be cheap and side-effect free (`available()` calls it
+     * per command).
+     */
     readonly when?: () => boolean;
     /** Hard off-switch — `false` hides the command from `available()` regardless of `when`. Defaults to `true`. */
     readonly enabled?: boolean;
-    /** The handler. May be sync or async; the registry awaits it and routes a rejection to its `onError`. */
-    readonly run: (context?: CommandContext) => void | Promise<void>;
+    /** Expected failures return Result; total handlers may return void. Programmer exceptions remain exceptional. */
+    readonly run: (context?: CommandContext) => void | Result | Promise<void | Result>;
 }
 /**
  * Reports whether a command may run right now — `enabled !== false` **and** `when()` (when present) passing.
  * Exported so a surface holding a plain array (not a registry) applies the same rule the registry does.
- * Propagates a throw from `when`; `registry.run` guards against that, direct callers should not pass a throwing predicate.
+ * Programmer exceptions from a broken predicate propagate; registry execution reports them before rejecting.
  */
 export declare function isCommandAvailable(command: Command): boolean;
-/**
- * Defines the result of `registry.run(...)`. Every path resolves to one of these — the registry never throws, so a
- * keystroke handler needs no try/catch and a caller can distinguish "no such command" from "blocked" from "failed".
- */
-export declare const CommandRunOutcome: {
-    /** The handler ran to completion (an async handler resolved). */
-    readonly Ran: "ran";
-    /** No command is registered under that id. */
-    readonly NotFound: "not-found";
-    /** The command exists but `when()` / `enabled` blocked it. */
-    readonly Unavailable: "unavailable";
-    /** The handler threw or rejected — the error was routed to the registry's `onError`. */
-    readonly Failed: "failed";
-};
-export type CommandRunOutcome = (typeof CommandRunOutcome)[keyof typeof CommandRunOutcome];