@adcops/autocore-react 3.5.9 → 3.5.13

package/tools/tests/dist/varpick.entry.js

@@ -0,0 +1,113 @@
+import { Q as __toESM, X as require_client, Z as require_react, a as configSourceCatalog, d as require_jsx_runtime, i as chartFieldCatalog, n as AuthoringContext, o as cycleSourceCatalog, r as boundCatalog, t as TestFieldDialog } from "./TestFieldDialog-C4mKVh7q.js";
+//#region src/hooks/useSequenceProducers.ts
+var import_client = require_client();
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+/** Every `store_value` name in a method, `cycle` bodies included. */
+function collectStoredNames(method) {
+	const out = [];
+	const walk = (steps) => {
+		if (!Array.isArray(steps)) return;
+		for (const s of steps) {
+			if (!s || typeof s !== "object") continue;
+			if (s.type === "cycle") walk(s.body);
+			if (s.type === "store_value" && typeof s.name === "string" && s.name.trim() !== "") {
+				if (!out.includes(s.name)) out.push(s.name);
+			}
+		}
+	};
+	walk(method?.steps);
+	return out;
+}
+//#endregion
+//#region tools/tests/varpick.entry.tsx
+/**
+* Fixture for `tools/tests/varpick.test.mjs`.
+*
+* Mounts a real `TestFieldDialog` under a real `AuthoringContext`, so the test
+* drives the whole chain the way an author does: open the picker, search,
+* select, Insert, and check what landed in the field. The pure catalog builders
+* are exported alongside so the same run can assert on the lists themselves.
+*/
+var import_jsx_runtime = require_jsx_runtime();
+var VARIABLES = [
+	{
+		fqdn: "gm.press_position",
+		name: "press_position",
+		type: "f64",
+		description: "Press position, mm — datum-corrected by the motion engine",
+		quantity: "position",
+		ux: true,
+		nonvolatile: false,
+		link: "ethercat.motion.z.position",
+		writable: false,
+		is_signal: false
+	},
+	{
+		fqdn: "gm.press_preload_n",
+		name: "press_preload_n",
+		type: "f64",
+		description: "Seating (preload) force. NEGATIVE = compression.",
+		quantity: "force",
+		ux: true,
+		nonvolatile: true,
+		writable: true,
+		is_signal: false
+	},
+	{
+		fqdn: "gm.press_force_min_n",
+		name: "press_force_min_n",
+		type: "f64",
+		description: "Signed lower force bound for the fitted load cell.",
+		quantity: "force",
+		ux: true,
+		nonvolatile: false,
+		writable: true,
+		is_signal: false
+	}
+];
+var PRODUCED = [
+	"preload_load",
+	"test_load",
+	"deflection"
+];
+var saved = null;
+var currentArray = "cycle_fields";
+var setArray = () => {};
+var Harness = () => {
+	const [arrayKey, setArrayKey] = (0, import_react.useState)("cycle_fields");
+	setArray = setArrayKey;
+	currentArray = arrayKey;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthoringContext.Provider, {
+		value: {
+			variables: VARIABLES,
+			producedNames: PRODUCED
+		},
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestFieldDialog, {
+			visible: true,
+			initial: {
+				name: "preload_load",
+				type: "f32"
+			},
+			siblingNames: ["preload_load", "test_load"],
+			isCycleField: arrayKey === "cycle_fields",
+			onCancel: () => {},
+			onSave: (f) => {
+				saved = f;
+			}
+		})
+	});
+};
+window.__mount = () => (0, import_client.createRoot)(document.getElementById("root")).render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Harness, {}));
+window.__saved = () => saved;
+window.__setArray = (a) => setArray(a);
+window.__currentArray = () => currentArray;
+window.__catalogs = {
+	boundCatalog,
+	chartFieldCatalog,
+	configSourceCatalog,
+	cycleSourceCatalog,
+	collectStoredNames,
+	VARIABLES,
+	PRODUCED
+};
+//#endregion

package/tools/tests/live-server.probe.mjs

@@ -0,0 +1,172 @@
+/**
+ * Live-server probe for the variable picker — `npm run probe:live`.
+ *
+ * NOT part of `npm test`: it needs a running `autocore_server`, so it is opt-in.
+ * What it covers that the jsdom tests cannot is the SEAM — the real
+ * `gm.get_variables` payload against the `GmVariable` type the client declares,
+ * and that payload fed through the published catalog builders. A field that the
+ * server renames or stops sending breaks the picker silently otherwise: the
+ * list just comes back empty or undescribed.
+ *
+ * ## Running it without hardware
+ *
+ * The debug binary reads `config.ubuntu.ini` from its CWD, so point a scratch
+ * copy at any project and run it there:
+ *
+ *   mkdir -p /tmp/acsrv/projects && cd /tmp/acsrv
+ *   cp -r <project> projects/            # a COPY: the server writes GNV + datastore
+ *   cat > config.ubuntu.ini <<EOF
+ *   [general]
+ *   projects_directory=/tmp/acsrv/projects
+ *   project_name=<project>
+ *   port=8099
+ *   ipc_port=9199
+ *   disable_ads=1
+ *   [modules]
+ *   EOF
+ *   /home/user/repos/autocore-server/target/debug/autocore_server
+ *
+ * Leave `[modules]` empty. Without hardware the ethercat/motion modules never
+ * connect and the control program is held — which does not matter here:
+ * `gm.get_variables` is served by the SERVER itself (gm_servelet), and `tis.*`
+ * is an always-on SYSTEM module that needs the datastore, not a machine.
+ *
+ * `tis`/`ams` are not declared in project.json — the server launches them
+ * itself, looking in `<server-exe-dir>/modules/`, then
+ * `../autocore-<name>/target/release/`, then PATH. A debug tree has neither, so
+ * symlink them once or the TIS half of this probe times out:
+ *
+ *   mkdir -p autocore-server/target/debug/modules
+ *   ln -s ../../../../autocore-tis/target/debug/autocore-tis \
+ *         autocore-server/target/debug/modules/autocore-tis
+ *   ln -s ../../../../autocore-ams/target/debug/autocore-ams \
+ *         autocore-server/target/debug/modules/autocore-ams
+ *
+ * What still cannot be reached on a bench is `motion.*` — the motion manager
+ * starves its own request path retrying `configure_axes` against an ethercat
+ * that has no NIC. So the sequence editor's axis ENVELOPE (v_max/a_max/travel)
+ * is the one thing here that only hardware can confirm.
+ *
+ * Expects the server on 127.0.0.1:8080; edit the URL below for another port.
+ */
+
+import WebSocket from 'ws';
+import { gmCatalog, searchCatalog, allEntries } from '@adcops/autocore-varpick';
+
+const ws = new WebSocket('ws://127.0.0.1:8080/ws/');
+let id = 1; const pending = new Map();
+const invoke = (topic, mt, data) => new Promise((res, rej) => {
+    const transaction_id = id++;
+    pending.set(transaction_id, res);
+    ws.send(JSON.stringify({ transaction_id, timecode: Date.now(), topic, message_type: mt, data, success: true, error_message: '' }));
+    setTimeout(() => { if (pending.delete(transaction_id)) rej(new Error(`timeout ${topic}`)); }, 8000);
+});
+ws.on('message', b => { let m; try { m = JSON.parse(b.toString()); } catch { return; }
+    const r = pending.get(m.transaction_id); if (r) { pending.delete(m.transaction_id); r(m); } });
+
+let pass = 0;
+const ok = (n, c, d = '') => { if (c) { pass++; console.log(`PASS  ${n}`); }
+    else { console.error(`FAIL  ${n} ${d}`); process.exitCode = 1; } };
+const eq = (n, g, w) => ok(n, JSON.stringify(g) === JSON.stringify(w), `got ${JSON.stringify(g)} want ${JSON.stringify(w)}`);
+
+ws.on('open', async () => {
+  try {
+    const resp = await invoke('gm.get_variables', 10, {});
+    ok('gm.get_variables succeeds', resp.success === true, resp.error_message);
+    const vars = resp.data.variables;
+    ok('returns the whole table', vars.length > 100, `n=${vars.length}`);
+
+    // -- the shape the TS GmVariable type declares --
+    const required = ['fqdn', 'name', 'type', 'description', 'ux', 'nonvolatile', 'writable', 'is_signal'];
+    const missing = vars.filter(v => required.some(k => v[k] === undefined));
+    eq('every row carries every non-optional field', missing.map(v => v.name), []);
+    ok('fqdn is the gm.-prefixed spelling', vars.every(v => v.fqdn === `gm.${v.name.toLowerCase()}`));
+    ok('sorted by name', vars.map(v => v.name).join() === vars.map(v => v.name).sort().join());
+
+    const by = n => vars.find(v => v.name === n);
+
+    // -- quantity survived the VariableConfig round-trip (it was NOT in the struct) --
+    eq('press_position.quantity', by('press_position')?.quantity, 'position');
+    eq('press_preload_n.quantity', by('press_preload_n')?.quantity, 'force');
+    // Exactly the 20 project.json declares — the point is that NONE are lost
+    // in the typed round-trip, which is what `quantity` used to do.
+    eq('every declared quantity survives', vars.filter(v => v.quantity).length, 20);
+
+    // -- writable is derived from link, which is what filters the config picker --
+    eq('a linked variable is not writable', by('press_position')?.writable, false);
+    eq('...and reports its producer', by('press_position')?.link, 'ethercat.motion.z.position');
+    eq('an unlinked setting is writable', by('press_preload_n')?.writable, true);
+    eq('signals are flagged', by('tick')?.is_signal, true);
+
+    // -- descriptions actually arrive: the whole point --
+    ok('press_position describes itself', /datum-corrected/.test(by('press_position')?.description ?? ''),
+       by('press_position')?.description);
+    const described = vars.filter(v => (v.description ?? '').trim()).length;
+    ok('nearly everything is described', described / vars.length > 0.9,
+       `${described}/${vars.length}`);
+
+    // -- the LIVE payload through the PUBLISHED catalog builders --
+    const unitFor = q => ({ position: 'mm', force: 'N' })[q];
+    const cfg = gmCatalog(vars, { spelling: 'fqdn', writableOnly: true, unitFor });
+    const bound = gmCatalog(vars, { spelling: 'token', unitFor });
+    ok('config picker drops hardware-owned variables',
+       !allEntries(cfg).some(e => e.name === 'press_position'));
+    ok('config picker keeps the operator settings',
+       allEntries(cfg).some(e => e.name === 'press_preload_n'));
+    eq('bound picker spells a token',
+       allEntries(bound).find(e => e.name === 'press_force_min_n')?.insert, '${gm.press_force_min_n}');
+    eq('units come through', allEntries(bound).find(e => e.name === 'press_position')?.unit, 'mm');
+    eq('groups present', bound.map(g => g.id), ['measured', 'settings', 'program', 'signals']);
+
+    // -- search over real data: find a thing by what it MEANS --
+    const hits = q => allEntries(searchCatalog(bound, q)).map(e => e.name);
+    ok('"EL3356" finds the load cell', hits('EL3356').includes('zforce_load'), hits('EL3356').join());
+    ok('"preload" finds the seating force', hits('preload').includes('press_preload_n'));
+    ok('a nonsense query finds nothing', hits('zzzznope').length === 0);
+
+    // ── the TIS half: both producers of a cycle column ──────────────────
+    //
+    // This is the pairing the cycle-field Source picker exists to show, and
+    // neither side checks the other at run time: `tis.add_cycle` writes
+    // `cycle_data` verbatim, so a declared column nothing stores is blank
+    // forever and a stored name with no column is recorded invisibly.
+    const tis = await invoke('tis.show_config', 10, {});
+    ok('tis.show_config succeeds', tis.success === true, tis.error_message);
+    const method = tis.data?.test_methods?.golf_compression;
+    ok('the method is served', !!method);
+
+    const declared = (method?.cycle_fields ?? []).map(f => f.name);
+    eq('cycle columns as declared', declared,
+       ['preload_load', 'preload_position', 'test_load', 'test_position', 'deflection']);
+    ok('none of them declares a GM source',
+       (method?.cycle_fields ?? []).every(f => !f.source),
+       'on this machine the sequence fills them by name');
+
+    const seq = await invoke('datastore.methods/golf_compression.seq.json', 2, {});
+    ok('the sequence reads back', seq.success === true);
+    const steps = seq.data?.steps ?? [];
+    const produced = steps.filter(s => s.type === 'store_value').map(s => s.name);
+
+    // The contract the picker makes visible, asserted here against live data.
+    eq('every declared column has a producer', declared.filter(d => !produced.includes(d)), []);
+    eq('every produced name has a column', produced.filter(pn => !declared.includes(pn)), []);
+
+    // -- the rename actually reached the shipped method --
+    const triggers = steps.filter(s => s.type === 'scope_point').map(s => s.trigger.source);
+    eq('scope points read the renamed signal', [...new Set(triggers)], ['load']);
+    const exprs = steps.flatMap(s => (s.capture ?? []).map(c => c.expr));
+    ok('captures use the renamed signals', exprs.every(e => e === 'load' || e === 'position'),
+       exprs.join());
+    const retract = steps.find(s => s.kind === 'move_to_position');
+    eq('retract uses the renamed start position', retract?.params?.position, 'start_position');
+
+    // -- a live bound token resolves to a real variable --
+    const tl = (method?.config_fields ?? []).find(f => f.name === 'target_load');
+    eq('target_load keeps its token bound', tl?.min, '${gm.press_force_min_n}');
+    ok('...and that variable exists', vars.some(v => v.fqdn === 'gm.press_force_min_n'));
+
+    console.log(`\nlive server: ${pass} checks passed`);
+  } catch (e) { console.error('ERROR', e); process.exitCode = 1; }
+  ws.close(); process.exit(process.exitCode ?? 0);
+});
+ws.on('error', e => { console.error('WS ERROR', e.message); process.exit(1); });

package/tools/tests/varpick.entry.tsx

@@ -0,0 +1,81 @@
+/**
+ * Fixture for `tools/tests/varpick.test.mjs`.
+ *
+ * Mounts a real `TestFieldDialog` under a real `AuthoringContext`, so the test
+ * drives the whole chain the way an author does: open the picker, search,
+ * select, Insert, and check what landed in the field. The pure catalog builders
+ * are exported alongside so the same run can assert on the lists themselves.
+ */
+
+import * as React from 'react';
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { TestFieldDialog } from '../../src/components/tis-editor/editor/TestFieldDialog';
+import { AuthoringContext } from '../../src/components/tis-editor/editor/AuthoringContext';
+import {
+    boundCatalog,
+    chartFieldCatalog,
+    configSourceCatalog,
+    cycleSourceCatalog,
+} from '../../src/components/varpick';
+import { collectStoredNames } from '../../src/hooks/useSequenceProducers';
+import type { GmVariable } from '@adcops/autocore-varpick';
+
+const VARIABLES: GmVariable[] = [
+    {
+        fqdn: 'gm.press_position', name: 'press_position', type: 'f64',
+        description: 'Press position, mm — datum-corrected by the motion engine',
+        quantity: 'position', ux: true, nonvolatile: false,
+        link: 'ethercat.motion.z.position', writable: false, is_signal: false,
+    },
+    {
+        fqdn: 'gm.press_preload_n', name: 'press_preload_n', type: 'f64',
+        description: 'Seating (preload) force. NEGATIVE = compression.',
+        quantity: 'force', ux: true, nonvolatile: true, writable: true, is_signal: false,
+    },
+    {
+        fqdn: 'gm.press_force_min_n', name: 'press_force_min_n', type: 'f64',
+        description: 'Signed lower force bound for the fitted load cell.',
+        quantity: 'force', ux: true, nonvolatile: false, writable: true, is_signal: false,
+    },
+];
+
+const PRODUCED = ['preload_load', 'test_load', 'deflection'];
+
+let saved: any = null;
+let currentArray: 'cycle_fields' | 'config_fields' = 'cycle_fields';
+let setArray: (a: 'cycle_fields' | 'config_fields') => void = () => {};
+
+const Harness: React.FC = () => {
+    const [arrayKey, setArrayKey] = useState<'cycle_fields' | 'config_fields'>('cycle_fields');
+    setArray = setArrayKey;
+    currentArray = arrayKey;
+    return (
+        <AuthoringContext.Provider value={{ variables: VARIABLES, producedNames: PRODUCED }}>
+            <TestFieldDialog
+                visible
+                initial={{ name: 'preload_load', type: 'f32' }}
+                siblingNames={['preload_load', 'test_load']}
+                isCycleField={arrayKey === 'cycle_fields'}
+                onCancel={() => {}}
+                onSave={(f) => { saved = f; }}
+            />
+        </AuthoringContext.Provider>
+    );
+};
+
+(window as any).__mount = () => createRoot(document.getElementById('root')!).render(<Harness />);
+(window as any).__saved = () => saved;
+(window as any).__setArray = (a: 'cycle_fields' | 'config_fields') => setArray(a);
+(window as any).__currentArray = () => currentArray;
+
+// Pure builders, for the assertions that need no DOM.
+(window as any).__catalogs = {
+    boundCatalog,
+    chartFieldCatalog,
+    configSourceCatalog,
+    cycleSourceCatalog,
+    collectStoredNames,
+    VARIABLES,
+    PRODUCED,
+};

package/tools/tests/varpick.test.mjs

@@ -0,0 +1,208 @@
+/**
+ * Variable-picker regression test — `npm run test:varpick`.
+ *
+ * Two halves:
+ *
+ *  1. The catalogs. Each field in the method editor wants a different list,
+ *     spelled differently, and every way of getting it wrong fails SILENTLY —
+ *     a `source` that names nothing never binds, a bound that resolves to
+ *     nothing is simply unlimited, a cycle column with no producer is blank on
+ *     every row forever.
+ *  2. The dialog, driven end to end in jsdom: open the picker, search, select,
+ *     Insert, and check what landed in the field. That is the part a unit test
+ *     of the model cannot cover — it is where the spelling is chosen.
+ */
+
+import { JSDOM } from 'jsdom';
+
+const dom = new JSDOM('<!doctype html><html><body><div id="root"></div></body></html>', {
+    url: 'http://localhost/', pretendToBeVisual: true,
+});
+global.window = dom.window;
+global.document = dom.window.document;
+Object.defineProperty(global, 'navigator', { value: dom.window.navigator, configurable: true });
+global.HTMLElement = dom.window.HTMLElement;
+global.Element = dom.window.Element;
+global.Node = dom.window.Node;
+global.Event = dom.window.Event;
+global.KeyboardEvent = dom.window.KeyboardEvent;
+global.MouseEvent = dom.window.MouseEvent;
+global.getComputedStyle = dom.window.getComputedStyle;
+global.requestAnimationFrame = (cb) => setTimeout(() => cb(Date.now()), 0);
+global.cancelAnimationFrame = (id) => clearTimeout(id);
+global.IS_REACT_ACT_ENVIRONMENT = true;
+dom.window.IS_REACT_ACT_ENVIRONMENT = true;
+global.matchMedia = dom.window.matchMedia ?? (() => ({
+    matches: false, addListener() {}, removeListener() {},
+    addEventListener() {}, removeEventListener() {},
+}));
+
+await import('./dist/varpick.entry.js');
+const { act } = await import('react');
+
+const tick = async () => { await act(async () => { await new Promise(r => setTimeout(r, 20)); }); };
+
+let passed = 0;
+const check = (name, got, want) => {
+    const g = JSON.stringify(got);
+    const w = JSON.stringify(want);
+    if (g === w) { passed++; console.log(`PASS  ${name}: ${g}`); }
+    else { console.error(`FAIL  ${name}\n      got  ${g}\n      want ${w}`); process.exitCode = 1; }
+};
+const ok = (name, cond, detail = '') => {
+    if (cond) { passed++; console.log(`PASS  ${name}`); }
+    else { console.error(`FAIL  ${name} ${detail}`); process.exitCode = 1; }
+};
+
+// ── 1. the catalogs ─────────────────────────────────────────────────────────
+
+const C = window.__catalogs;
+const ctx = { variables: C.VARIABLES, unitFor: (q) => ({ position: 'mm', force: 'N' })[q] };
+const flat = (cat) => cat.flatMap(g => g.entries);
+const inserts = (cat) => flat(cat).map(e => e.insert);
+const groupIds = (cat) => cat.map(g => g.id);
+
+{
+    // A config field's Source is WRITTEN by the setup form, so a variable a
+    // module republishes every scan must not be offered: the operator's entry
+    // would be overwritten before anything read it.
+    const cat = C.configSourceCatalog(ctx);
+    check('config source omits hardware-owned variables', inserts(cat),
+        ['gm.press_preload_n', 'gm.press_force_min_n']);
+    ok('config source spells an FQDN', inserts(cat).every(i => i.startsWith('gm.')));
+
+    const bounds = C.boundCatalog(ctx);
+    check('a bound is spelled as a token', inserts(bounds).slice(0, 1), ['${gm.press_position}']);
+    ok('a bound may read a hardware-owned variable',
+        inserts(bounds).includes('${gm.press_position}'));
+    check('units come from the machine, not the name',
+        flat(bounds).find(e => e.name === 'press_position').unit, 'mm');
+}
+
+{
+    // The two-producer case. A cycle field on gen4_ac is filled by a
+    // `store_value` matched by NAME, with `source` left empty — so a picker
+    // that only offered FQDNs would wire a binding that never fills.
+    const cat = C.cycleSourceCatalog(ctx, { producedNames: C.PRODUCED, fieldName: 'preload_load' });
+    check('the sequence is offered first', groupIds(cat)[0], 'sequence');
+    ok('GM variables are still offered', groupIds(cat).includes('measured'));
+
+    const seq = cat[0].entries;
+    check('choosing a sequence value CLEARS the source', seq.map(e => e.insert), ['', '', '']);
+    check('the matching name is called out',
+        seq.find(e => e.name === 'preload_load').note, undefined);
+    ok('a mismatched name says what to do',
+        /Rename this field to "test_load"/.test(seq.find(e => e.name === 'test_load').note),
+        seq.find(e => e.name === 'test_load').note);
+
+    // No sequence read → no group, rather than an empty one claiming nothing
+    // produces anything.
+    const none = C.cycleSourceCatalog(ctx, {});
+    ok('an unread sequence adds no group', !groupIds(none).includes('sequence'));
+}
+
+{
+    const raw = C.chartFieldCatalog({
+        viewType: 'raw_trace', rawColumns: ['t', 'force'], cycleFields: ['peak'], resultsFields: [],
+    });
+    check('a raw_trace offers trace columns first', groupIds(raw), ['raw', 'cycle']);
+    const scatter = C.chartFieldCatalog({
+        viewType: 'cycle_scatter', rawColumns: ['t'], cycleFields: ['peak'], testFields: ['operator'],
+    });
+    check('a cycle_scatter offers cycle columns first', groupIds(scatter), ['cycle', 'raw', 'test']);
+}
+
+{
+    // A repeated measurement lives inside a `cycle` body, so a walk that
+    // stopped at the top level would miss the methods that record the most.
+    const method = {
+        steps: [
+            { type: 'store_value', name: 'a', expr: 'x' },
+            { type: 'cycle', count: '3', body: [{ type: 'store_value', name: 'b', expr: 'y' }] },
+            { type: 'store_value', name: 'a', expr: 'z' },
+            { type: 'store_value', name: '', expr: 'q' },
+            { type: 'push_row' },
+        ],
+    };
+    check('stored names include cycle bodies, deduped, blanks dropped',
+        C.collectStoredNames(method), ['a', 'b']);
+    check('a non-method reads as no names', C.collectStoredNames({ steps: null }), []);
+}
+
+// ── 2. the dialog, end to end ───────────────────────────────────────────────
+
+await act(async () => { window.__mount(); });
+await tick();
+
+const q = (sel) => [...document.querySelectorAll(sel)];
+const dialogs = () => q('.p-dialog');
+const rowLabelled = (label) =>
+    q('.ac-formrow').find(r => r.querySelector('.ac-formrow__label')?.textContent?.startsWith(label));
+const inputIn = (label) => rowLabelled(label)?.querySelector('input');
+const pickerButtonIn = (label) => rowLabelled(label)?.querySelector('button');
+const setValue = (el, v) => {
+    const desc = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(el), 'value');
+    desc.set.call(el, v);
+    el.dispatchEvent(new dom.window.Event('input', { bubbles: true }));
+};
+const click = async (el) => {
+    await act(async () => { el.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true })); });
+    await tick();
+};
+/** The picker dialog is the last one opened, over the field dialog. */
+const picker = () => dialogs().at(-1);
+const pickerRows = () => [...picker().querySelectorAll('.ac-varpick__row')];
+const buttonLabelled = (root, text) =>
+    [...root.querySelectorAll('button')].find(b => b.textContent?.trim() === text);
+
+ok('every field dialog input still renders', inputIn('Source') !== undefined);
+ok('Source has a picker button',
+    pickerButtonIn('Source')?.getAttribute('aria-label') === 'Choose a source for this field');
+
+// -- a cycle field picks a SEQUENCE producer, which clears Source ------------
+setValue(inputIn('Source'), 'gm.stale_binding');
+await tick();
+check('typing still works', inputIn('Source').value, 'gm.stale_binding');
+
+await click(pickerButtonIn('Source'));
+ok('the picker opened', dialogs().length > 1, `dialogs=${dialogs().length}`);
+ok('the sequence group is present',
+    picker().textContent.includes('Recorded by the sequence'));
+
+const preloadRow = pickerRows().find(r => r.querySelector('code')?.textContent === 'preload_load');
+ok('the matching produced name is listed', preloadRow !== undefined);
+await click(preloadRow);
+await click(buttonLabelled(picker(), 'Insert'));
+check('picking a sequence producer clears Source', inputIn('Source').value, '');
+
+// -- a bound picks a token --------------------------------------------------
+await click(pickerButtonIn('Min'));
+const searchBox = picker().querySelector('.ac-varpick__search');
+setValue(searchBox, 'lower force bound');
+await tick();
+check('a variable is findable by what it MEANS',
+    pickerRows().map(r => r.querySelector('code').textContent), ['press_force_min_n']);
+await click(pickerRows()[0]);
+await click(buttonLabelled(picker(), 'Insert'));
+check('a bound is inserted as a token', inputIn('Min').value, '${gm.press_force_min_n}');
+
+// -- the saved field carries both -------------------------------------------
+const dialogRoot = dialogs()[0];
+await click(buttonLabelled(dialogRoot, 'Save'));
+const saved = window.__saved();
+ok('the field saved', saved !== null);
+check('source stayed cleared', saved?.source, undefined);
+check('min saved as a token', saved?.min, '${gm.press_force_min_n}');
+
+// -- a config field offers only writable variables ---------------------------
+await act(async () => { window.__setArray('config_fields'); });
+await tick();
+await click(pickerButtonIn('Source'));
+ok('a config field is not offered the sequence',
+    !picker().textContent.includes('Recorded by the sequence'));
+ok('a config field is not offered a hardware-owned variable',
+    !pickerRows().some(r => r.querySelector('code')?.textContent === 'press_position'),
+    pickerRows().map(r => r.querySelector('code')?.textContent).join(','));
+
+console.log(`\nvarpick: ${passed} checks passed`);
+if (process.exitCode) console.error('varpick: FAILURES');

package/tools/tests/vite.config.mjs

@@ -17,9 +17,14 @@ export default defineConfig({
         outDir: resolve(here, 'dist'),
         emptyOutDir: true,
         lib: {
-            entry: resolve(here, 'tis-editor.entry.tsx'),
+            // Named entries so each test file imports its own bundle by name;
+            // shared code (React, PrimeReact) is hoisted into one chunk, which
+            // is what keeps a single copy of React in the jsdom run.
+            entry: {
+                'tis-editor.entry': resolve(here, 'tis-editor.entry.tsx'),
+                'varpick.entry': resolve(here, 'varpick.entry.tsx'),
+            },
             formats: ['es'],
-            fileName: 'tis-editor.entry',
         },
         minify: false,
         target: 'node20',