@buoy-gg/zustand 7.0.38 → 7.0.40

package/lib/commonjs/zustand/utils/editableState.js

@@ -1 +1,146 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.STRIP_MAX_DEPTH=void 0,exports.computeMergePartial=computeMergePartial,exports.editableStateOf=editableStateOf,exports.isPlainObjectLike=isPlainObjectLike,exports.stripFunctions=stripFunctions;const STRIP_MAX_DEPTH=exports.STRIP_MAX_DEPTH=8;function isPlainObjectLike(e){if("object"!=typeof e||null===e||Array.isArray(e))return!1;const t=Object.getPrototypeOf(e);return t===Object.prototype||null===t}function stripFunctions(e,t,n,i,r){if("function"==typeof e)return void n.push(t);if("object"!=typeof e||null===e||r>=STRIP_MAX_DEPTH)return e;if(i.has(e))return;if(i.add(e),Array.isArray(e))return e.map((e,s)=>"function"==typeof e?(n.push(`${t}[${s}]`),null):stripFunctions(e,`${t}[${s}]`,n,i,r+1));if(!isPlainObjectLike(e))return e;const s={};for(const[o,a]of Object.entries(e))"function"!=typeof a?s[o]=stripFunctions(a,t?`${t}.${o}`:o,n,i,r+1):n.push(t?`${t}.${o}`:o);return s}function editableStateOf(e){if(isPlainObjectLike(e)&&!0===e.__buoyStateOnDevice)return{data:null,fnPaths:[],blockedReason:"Store state hasn't synced from the device yet."};if(!isPlainObjectLike(e))return{data:null,fnPaths:[],blockedReason:"Only stores whose state is a plain object can be edited — a merge write has nothing to address in "+(Array.isArray(e)?"an array":"a "+typeof e)+"."};const t=[],n=stripFunctions(e,"",t,new WeakSet,0),i=t.filter(e=>e.includes(".")||e.includes("["));return i.length>0?{data:null,fnPaths:t,blockedReason:`State keeps a function inside "${i[0]}" — a merge write of that key would drop it, so this store can't be edited here.`}:{data:n,fnPaths:t,blockedReason:null}}function computeMergePartial(e,t){if(!isPlainObjectLike(t))throw new Error("The store's state must stay an object.");const n=Object.keys(e).filter(e=>!(e in t));if(n.length>0)throw new Error(`Can't remove top-level ${1===n.length?"key":"keys"} ${n.map(e=>`"${e}"`).join(", ")} — zustand merge writes can't delete. Edit the value instead.`);const i={};for(const n of Object.keys(t))n in e&&JSON.stringify(t[n])===JSON.stringify(e[n])||(i[n]=t[n]);return i}
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STRIP_MAX_DEPTH = void 0;
+exports.computeMergePartial = computeMergePartial;
+exports.editableStateOf = editableStateOf;
+exports.isPlainObjectLike = isPlainObjectLike;
+exports.stripFunctions = stripFunctions;
+/**
+ * What of a zustand store's state can be EDITED, and how an edit is written.
+ *
+ * The two zustand facts every rule here follows from:
+ *
+ * 1. Stores conventionally keep their action functions IN state
+ *    (`increment: () => …`). Functions can't be typed into a tree editor and
+ *    don't survive serialization, so the editor works on a function-free view
+ *    of state.
+ * 2. `setState` is either a TOP-LEVEL SHALLOW MERGE (`Object.assign({}, state,
+ *    partial)`) or a full replace that deletes every key not present — actions
+ *    included. So the editor writes merge-only, always: every edit, however
+ *    deep, is expressed as "replace the top-level key(s) that contain it"
+ *    ({@link computeMergePartial}), and the two edits a merge cannot express —
+ *    removing or renaming a top-level key — are refused rather than silently
+ *    not happening.
+ *
+ * `stripFunctions` lives here (the Time Machine snapshot provider imports it)
+ * because capture and editing need the identical answer to "what is this
+ * store's data".
+ */
+
+/** Bounds every recursive walk over store state. */
+const STRIP_MAX_DEPTH = exports.STRIP_MAX_DEPTH = 8;
+function isPlainObjectLike(v) {
+  // Only objects whose own enumerable keys ARE their data. A Map, Set, Date,
+  // RegExp or typed array has none, so walking it with Object.entries turns
+  // it into `{}` — which is how a restored store once got `{}` where the app
+  // kept a Map and crashed on `.values()`. Those go through as-is; the vault's
+  // superjson knows how to carry them.
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+/** Clone `value` without functions, recording their paths. */
+function stripFunctions(value, path, fnPaths, seen, depth) {
+  if (typeof value === "function") {
+    fnPaths.push(path);
+    return undefined;
+  }
+  if (typeof value !== "object" || value === null || depth >= STRIP_MAX_DEPTH) {
+    return value;
+  }
+  if (seen.has(value)) return undefined; // cycle — drop the back-reference
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item, i) => typeof item === "function" ? (fnPaths.push(`${path}[${i}]`), null) : stripFunctions(item, `${path}[${i}]`, fnPaths, seen, depth + 1));
+  }
+  if (!isPlainObjectLike(value)) return value; // Date/Map/Set/etc. — superjson handles
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "function") {
+      fnPaths.push(path ? `${path}.${k}` : k);
+      continue;
+    }
+    out[k] = stripFunctions(v, path ? `${path}.${k}` : k, fnPaths, seen, depth + 1);
+  }
+  return out;
+}
+/**
+ * The editor's view of one store's state, with the reasons it may refuse.
+ *
+ * - A remote mirror that hasn't hydrated yet holds a marker, not state — the
+ *   real value is one `getStoreState` round trip away, so "wait" rather than
+ *   "can't".
+ * - Non-object state (`create(() => 5)`) has no top-level keys, so a merge
+ *   write cannot address any part of it. Editing it would require a replace,
+ *   which is the destructive path this editor exists to avoid.
+ * - A function nested BELOW the top level (rare — the convention keeps actions
+ *   at the top) sits inside the very key an edit would rewrite, and a merge
+ *   write of that key would silently drop it. Refusing the whole store is
+ *   blunt but honest; per-key locks can come later if this ever bites.
+ */
+function editableStateOf(state) {
+  if (isPlainObjectLike(state) && state.__buoyStateOnDevice === true) {
+    return {
+      data: null,
+      fnPaths: [],
+      blockedReason: "Store state hasn't synced from the device yet."
+    };
+  }
+  if (!isPlainObjectLike(state)) {
+    return {
+      data: null,
+      fnPaths: [],
+      blockedReason: "Only stores whose state is a plain object can be edited — " + "a merge write has nothing to address in " + (Array.isArray(state) ? "an array" : `a ${typeof state}`) + "."
+    };
+  }
+  const fnPaths = [];
+  const data = stripFunctions(state, "", fnPaths, new WeakSet(), 0);
+  const nested = fnPaths.filter(p => p.includes(".") || p.includes("["));
+  if (nested.length > 0) {
+    return {
+      data: null,
+      fnPaths,
+      blockedReason: `State keeps a function inside "${nested[0]}" — a merge write of ` + "that key would drop it, so this store can't be edited here."
+    };
+  }
+  return {
+    data,
+    fnPaths,
+    blockedReason: null
+  };
+}
+
+/**
+ * Diff an edited draft against the state it was seeded from, as a `setState`
+ * MERGE partial: only the top-level keys whose contents changed.
+ *
+ * Diffed against the SEED, not the live state at save time, on purpose — the
+ * partial then carries exactly what the user changed, so a key the app wrote
+ * while the editor was open and the user never touched keeps the app's value
+ * (per-key last-write-wins, the same contract the draft's own dirtiness uses).
+ *
+ * Throws on the two edits a merge cannot express, naming the key: a draft
+ * that dropped a top-level key (which is also what a raw-JSON rename produces
+ * — the old key dropped, a new one added), because `setState(partial, false)`
+ * would leave it exactly as it was while the editor showed it gone.
+ */
+function computeMergePartial(seed, draft) {
+  if (!isPlainObjectLike(draft)) {
+    throw new Error("The store's state must stay an object.");
+  }
+  const dropped = Object.keys(seed).filter(k => !(k in draft));
+  if (dropped.length > 0) {
+    throw new Error(`Can't remove top-level ${dropped.length === 1 ? "key" : "keys"} ` + `${dropped.map(k => `"${k}"`).join(", ")} — zustand merge writes ` + "can't delete. Edit the value instead.");
+  }
+  const partial = {};
+  for (const key of Object.keys(draft)) {
+    if (!(key in seed) || JSON.stringify(draft[key]) !== JSON.stringify(seed[key])) {
+      partial[key] = draft[key];
+    }
+  }
+  return partial;
+}

package/lib/commonjs/zustand/utils/snapshotProvider.js

@@ -1 +1,209 @@
-"use strict";var _sharedUi=require("@buoy-gg/shared-ui"),_zustandStateStore=require("./zustandStateStore"),_editableState=require("./editableState");const MAX_DEPTH=_editableState.STRIP_MAX_DEPTH;function graftFunctions(t,e,s,a){if((0,_editableState.isPlainObjectLike)(e)&&(0,_editableState.isPlainObjectLike)(t)&&!(a>=MAX_DEPTH||s.has(e))){s.add(e);for(const[n,r]of Object.entries(e))if("function"==typeof r)t[n]=r;else if((0,_editableState.isPlainObjectLike)(r)){if(!(0,_editableState.isPlainObjectLike)(t[n])){if(!containsFunction(r,new WeakSet,a+1))continue;t[n]={}}graftFunctions(t[n],r,s,a+1)}}}function containsFunction(t,e,s){if(s>=MAX_DEPTH||e.has(t))return!1;e.add(t);for(const a of Object.values(t)){if("function"==typeof a)return!0;if((0,_editableState.isPlainObjectLike)(a)&&containsFunction(a,e,s+1))return!0}return!1}function status(){return 0===_zustandStateStore.zustandStateStore.getStores().length?{canCapture:!1,canRestore:!1,detail:"No Zustand stores registered — pass `zustandStores` to FloatingDevTools or add the buoyDevTools middleware"}:{canCapture:!0,canRestore:!0}}async function capture(){const t=[],e={};for(const s of _zustandStateStore.zustandStateStore.getStores()){const a=[];let n;try{n=(0,_editableState.stripFunctions)(s.api.getState(),"",a,new WeakSet,0)}catch(e){t.push(`store "${s.name}": capture failed (${String(e)})`);continue}e[s.name]={state:n,fnPaths:a}}return{data:{stores:e},warnings:t}}async function restore(t,e){const s=t,a=(0,_sharedUi.createRestoreScope)(e),n=(0,_sharedUi.emptyRestoreResult)();if(!s?.stores)return(0,_sharedUi.failedRestore)("empty zustand snapshot");for(const[t,e]of Object.entries(s.stores)){if(!a.allows(t))continue;const s=_zustandStateStore.zustandStateStore.getStore(t);if(s)try{const a=e.state;graftFunctions(a,s.api.getState(),new WeakSet,0),s.api.setState(a,!0),s.api.getState()===a?n.applied+=1:(n.warnings.push(`store "${t}": setState did not take effect`),n.ok=!1)}catch(e){n.skipped.push({id:t,reason:String(e)}),n.ok=!1}else n.skipped.push({id:t,reason:"store not registered (renamed, or created after snapshot?)"})}const r=a.excludedWarning("store(s)");return r&&n.warnings.push(r),n}async function previewItems(t,e){const s=t?.stores??{},a=void 0===e,n={};if(a)for(const t of _zustandStateStore.zustandStateStore.getStores()){const e=[];try{n[t.name]={state:(0,_editableState.stripFunctions)(t.api.getState(),"",e,new WeakSet,0),fnPaths:e}}catch{}}else Object.assign(n,e?.stores??{});const r=[],o=[];let i=0;for(const t of(0,_sharedUi.unionKeys)(n,s)){const e=t in n;t in s?(i+=s[t].fnPaths?.length??0,!a||_zustandStateStore.zustandStateStore.getStore(t)?r.push((0,_sharedUi.classifyPreviewItem)({key:t,label:t,oldValue:n[t]?.state,newValue:s[t].state,inOld:e,inNew:!0},{tooLargeReason:"store too large to render a diff — restore still applies it"})):r.push({key:t,label:t,verdict:"wont-apply",reason:"store not registered (renamed, or created after snapshot?)"})):a?o.push(`store "${t}" not in snapshot — untouched`):r.push({key:t,label:t,verdict:"removed",oldValue:n[t].state})}return i>0&&o.push(`${i} store action function${1===i?"":"s"} preserved on restore (not diffed)`),{items:r,notes:o}}(0,_sharedUi.registerStateSnapshotProvider)({id:"zustand",label:"Zustand",status:status,capture:capture,restore:restore,previewItems:previewItems});
+"use strict";
+
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _zustandStateStore = require("./zustandStateStore");
+var _editableState = require("./editableState");
+/**
+ * Time Machine snapshot provider for Zustand.
+ *
+ * Registered into @buoy-gg/shared-ui's stateSnapshotRegistry at module init;
+ * consumed by @buoy-gg/time-machine. Neither package imports the other.
+ *
+ * The Zustand-specific hazard: stores conventionally keep their action
+ * functions IN state (`increment: () => ...`). Functions don't survive
+ * serialization, and a full `setState(snapshot, true)` replace would wipe
+ * them, breaking every `useStore(s => s.increment)` call site. So capture
+ * strips functions (recording where they were), and restore re-grafts the
+ * LIVE store's functions onto the snapshot before replacing.
+ */
+
+// The function-stripping walk is shared with the store editor (editableState
+// .ts) — capture and editing must agree on what a store's "data" is.
+const MAX_DEPTH = _editableState.STRIP_MAX_DEPTH;
+/**
+ * Copy every function-valued property from the LIVE state onto the restored
+ * snapshot (creating containers as needed), so store actions keep working
+ * after a full replace.
+ */
+function graftFunctions(target, live, seen, depth) {
+  if (!(0, _editableState.isPlainObjectLike)(live) || !(0, _editableState.isPlainObjectLike)(target)) return;
+  if (depth >= MAX_DEPTH || seen.has(live)) return;
+  seen.add(live);
+  for (const [k, v] of Object.entries(live)) {
+    if (typeof v === "function") {
+      target[k] = v;
+    } else if ((0, _editableState.isPlainObjectLike)(v)) {
+      if (!(0, _editableState.isPlainObjectLike)(target[k])) {
+        // Branch missing from the snapshot — only recreate it if it holds
+        // functions somewhere; otherwise the snapshot's absence wins.
+        if (!containsFunction(v, new WeakSet(), depth + 1)) continue;
+        target[k] = {};
+      }
+      graftFunctions(target[k], v, seen, depth + 1);
+    }
+  }
+}
+function containsFunction(value, seen, depth) {
+  if (depth >= MAX_DEPTH || seen.has(value)) return false;
+  seen.add(value);
+  for (const v of Object.values(value)) {
+    if (typeof v === "function") return true;
+    if ((0, _editableState.isPlainObjectLike)(v) && containsFunction(v, seen, depth + 1)) return true;
+  }
+  return false;
+}
+function status() {
+  const count = _zustandStateStore.zustandStateStore.getStores().length;
+  if (count === 0) {
+    return {
+      canCapture: false,
+      canRestore: false,
+      detail: "No Zustand stores registered — pass `zustandStores` to FloatingDevTools or add the buoyDevTools middleware"
+    };
+  }
+  return {
+    canCapture: true,
+    canRestore: true
+  };
+}
+async function capture() {
+  const warnings = [];
+  const stores = {};
+  for (const info of _zustandStateStore.zustandStateStore.getStores()) {
+    const fnPaths = [];
+    let state;
+    try {
+      state = (0, _editableState.stripFunctions)(info.api.getState(), "", fnPaths, new WeakSet(), 0);
+    } catch (e) {
+      warnings.push(`store "${info.name}": capture failed (${String(e)})`);
+      continue;
+    }
+    stores[info.name] = {
+      state,
+      fnPaths
+    };
+  }
+  return {
+    data: {
+      stores
+    },
+    warnings
+  };
+}
+async function restore(data, options) {
+  const snapshot = data;
+  const scope = (0, _sharedUi.createRestoreScope)(options);
+  const result = (0, _sharedUi.emptyRestoreResult)();
+  if (!snapshot?.stores) {
+    return (0, _sharedUi.failedRestore)("empty zustand snapshot");
+  }
+  for (const [name, envelope] of Object.entries(snapshot.stores)) {
+    if (!scope.allows(name)) continue;
+    const info = _zustandStateStore.zustandStateStore.getStore(name);
+    if (!info) {
+      result.skipped.push({
+        id: name,
+        reason: "store not registered (renamed, or created after snapshot?)"
+      });
+      continue;
+    }
+    try {
+      const next = envelope.state;
+      graftFunctions(next, info.api.getState(), new WeakSet(), 0);
+      info.api.setState(next, true);
+      if (info.api.getState() === next) {
+        result.applied += 1;
+      } else {
+        result.warnings.push(`store "${name}": setState did not take effect`);
+        result.ok = false;
+      }
+    } catch (e) {
+      result.skipped.push({
+        id: name,
+        reason: String(e)
+      });
+      result.ok = false;
+    }
+  }
+  const excludedWarning = scope.excludedWarning("store(s)");
+  if (excludedWarning) result.warnings.push(excludedWarning);
+  return result;
+}
+
+/**
+ * Per-store restore preview. Both sides are function-stripped through the
+ * SAME depth-8 normalizer as capture — diffing snapshot-vs-RAW-live would
+ * report every stripped function and every beyond-depth subtree as removed.
+ */
+async function previewItems(target, base) {
+  const targetStores = target?.stores ?? {};
+  const liveMode = base === undefined;
+  const baseStores = {};
+  if (liveMode) {
+    for (const info of _zustandStateStore.zustandStateStore.getStores()) {
+      const fnPaths = [];
+      try {
+        baseStores[info.name] = {
+          state: (0, _editableState.stripFunctions)(info.api.getState(), "", fnPaths, new WeakSet(), 0),
+          fnPaths
+        };
+      } catch {
+        // unreadable live store — treated as absent
+      }
+    }
+  } else {
+    Object.assign(baseStores, base?.stores ?? {});
+  }
+  const items = [];
+  const notes = [];
+  let preservedFns = 0;
+  for (const name of (0, _sharedUi.unionKeys)(baseStores, targetStores)) {
+    const inTarget = name in targetStores;
+    const inBase = name in baseStores;
+    if (!inTarget) {
+      // Restore never touches stores the snapshot doesn't know about.
+      if (liveMode) notes.push(`store "${name}" not in snapshot — untouched`);else items.push({
+        key: name,
+        label: name,
+        verdict: "removed",
+        oldValue: baseStores[name].state
+      });
+      continue;
+    }
+    preservedFns += targetStores[name].fnPaths?.length ?? 0;
+    if (liveMode && !_zustandStateStore.zustandStateStore.getStore(name)) {
+      items.push({
+        key: name,
+        label: name,
+        verdict: "wont-apply",
+        reason: "store not registered (renamed, or created after snapshot?)"
+      });
+      continue;
+    }
+    items.push((0, _sharedUi.classifyPreviewItem)({
+      key: name,
+      label: name,
+      oldValue: baseStores[name]?.state,
+      newValue: targetStores[name].state,
+      inOld: inBase,
+      inNew: true
+    }, {
+      tooLargeReason: "store too large to render a diff — restore still applies it"
+    }));
+  }
+  if (preservedFns > 0) {
+    notes.push(`${preservedFns} store action function${preservedFns === 1 ? "" : "s"} preserved on restore (not diffed)`);
+  }
+  return {
+    items,
+    notes
+  };
+}
+(0, _sharedUi.registerStateSnapshotProvider)({
+  id: "zustand",
+  label: "Zustand",
+  status,
+  capture,
+  restore,
+  previewItems
+});

package/lib/commonjs/zustand/utils/testIDs.js

@@ -1 +1,82 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ZUSTAND_TEST_ID=void 0,exports.buildChangeRowTestIDs=buildChangeRowTestIDs,exports.changeRowTestID=changeRowTestID,exports.slugForTestID=slugForTestID,exports.storeRowTestID=storeRowTestID;const ZUSTAND_TEST_ID=exports.ZUSTAND_TEST_ID="buoy-zustand";function slugForTestID(e){return String(e??"").toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}function changeRowTestID(e,t){return`${ZUSTAND_TEST_ID}-row-${slugForTestID(e)}-${t}`}function storeRowTestID(e){return`${ZUSTAND_TEST_ID}-store-${slugForTestID(e)}`}function buildChangeRowTestIDs(e){const t=new Map,s=new Map;for(const o of e){const e=(t.get(o.storeName)??0)+1;t.set(o.storeName,e),s.set(o.id,changeRowTestID(o.storeName,e))}return s}
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZUSTAND_TEST_ID = void 0;
+exports.buildChangeRowTestIDs = buildChangeRowTestIDs;
+exports.changeRowTestID = changeRowTestID;
+exports.slugForTestID = slugForTestID;
+exports.storeRowTestID = storeRowTestID;
+/**
+ * Zustand tool test handles.
+ *
+ * Every tappable and every value the e2e suite reads back is addressed
+ * `buoy-zustand-<thing>`. Two rules in here need explaining.
+ *
+ * **A change row's handle carries an ORDINAL, and it counts per STORE.** The
+ * Events tool can address a row by what it is about, because an event is a
+ * thing that happened to a named subject — one key, one URL, one atom. A
+ * zustand state change is not: a store that a screen writes to fifty times
+ * produces fifty separate, equally real rows. Addressing them by store name
+ * alone would give fifty views one handle, and Detox fails a *matcher* that
+ * hits more than one element — so a suite would break on `toExist()`, before
+ * any assertion, with an error that says nothing about duplicate changes.
+ *
+ * So the handle is `buoy-zustand-row-<slug(storeName)>-<n>`, where n counts
+ * back from the newest row of that store (1 = newest). Deliberately relative:
+ * a state change has no identity a host could know in advance — `id` is a
+ * timestamp plus a per-process counter whose value depends on how many
+ * changes the app happened to make before the test looked. What a test CAN
+ * know is "the set I just fired is the newest change to that store". Read and
+ * tap in one beat: a row's ordinal moves the instant another change lands.
+ *
+ * **A store row's handle does NOT.** A store is registered once under a name
+ * that is unique by construction (`zustandStateStore.registerStore` returns
+ * early on a name it already holds), so `buoy-zustand-store-<slug(name)>` is
+ * as stable as the store itself — and unlike a change, it is a thing the host
+ * knows the name of before the app has booted.
+ *
+ * The suite mirrors these rules in CommonJS (`example-dev-build/utils/
+ * zustandBench.js`) and asserts the two agree — Detox runs in Node on the host
+ * and cannot import TypeScript.
+ */
+
+/** Prefix every handle in this tool shares. */
+const ZUSTAND_TEST_ID = exports.ZUSTAND_TEST_ID = "buoy-zustand";
+
+/** `zbenchWatch` → `zbenchwatch`. Shared with every Buoy tool. */
+function slugForTestID(value) {
+  return String(value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+
+/**
+ * Handle for one change row: `buoy-zustand-row-zbenchwatch-1`.
+ *
+ * `ordinal` is 1-based and counts back from the newest row of this store.
+ */
+function changeRowTestID(storeName, ordinal) {
+  return `${ZUSTAND_TEST_ID}-row-${slugForTestID(storeName)}-${ordinal}`;
+}
+
+/** Handle for one store row in the browser: `buoy-zustand-store-zbenchwatch`. */
+function storeRowTestID(storeName) {
+  return `${ZUSTAND_TEST_ID}-store-${slugForTestID(storeName)}`;
+}
+
+/**
+ * Row handle per change id for one rendered list, newest-first.
+ *
+ * Built once for the whole list rather than per row, because an ordinal is a
+ * fact about the list and a row cannot compute its own.
+ */
+function buildChangeRowTestIDs(changes) {
+  const seen = new Map();
+  const handles = new Map();
+  for (const change of changes) {
+    const ordinal = (seen.get(change.storeName) ?? 0) + 1;
+    seen.set(change.storeName, ordinal);
+    handles.set(change.id, changeRowTestID(change.storeName, ordinal));
+  }
+  return handles;
+}