@adcops/autocore-react 3.5.7 → 3.5.11

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/tis-editor.entry.tsx

@@ -0,0 +1,46 @@
+/**
+ * Fixture for `tools/tests/tis-editor.test.mjs`.
+ *
+ * Mounts the two TIS-editor sections whose dialogs seed a draft from a record
+ * — the chart-view list and a field array — under a parent that can be made
+ * to re-render on demand. That re-render is the whole point: on a machine the
+ * editor sits under providers that re-render with live tag traffic, and the
+ * dialogs used to throw away the operator's typing every time one arrived.
+ */
+
+import * as React from 'react';
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { ViewsEditor } from '../../src/components/tis-editor/editor/ViewsEditor';
+import { orderedViews } from '../../src/components/tis/chartViews';
+import { FieldArrayEditor } from '../../src/components/tis-editor/editor/FieldArrayEditor';
+
+const METHOD: any = {
+    label: 'golf', cycle_fields: [{ name: 'peak_load' }, { name: 'deflection' }],
+    views: {
+        load_vs_deflection: { title: 'Peak Load vs Deflection (per cycle)', type: 'cycle_scatter', x: { field: 'deflection', label: 'Deflection' }, y: [{ field: 'peak_load', label: 'Peak Load', y_axis: 'left' }] },
+        peak_load_by_cycle: { title: 'Peak Load by Cycle', type: 'cycle_scatter', x: { field: 'cycle_index', label: 'Cycle' }, y: [{ field: 'peak_load', label: 'Peak Load', y_axis: 'left' }] },
+    },
+};
+
+let forceParentRender: () => void = () => {};
+let current: any = METHOD;
+
+const Harness: React.FC = () => {
+    const [, setTick] = useState(0);
+    const [method, setMethod] = useState<any>(METHOD);
+    forceParentRender = () => setTick(t => t + 1);
+    current = method;
+    const onChange = (m: any) => { current = m; setMethod(m); };
+    return (
+        <>
+            <ViewsEditor method={method} onChange={onChange} />
+            <FieldArrayEditor arrayKey="cycle_fields" method={method} onChange={onChange} />
+        </>
+    );
+};
+
+(window as any).__mount = () => createRoot(document.getElementById('root')!).render(<Harness />);
+(window as any).__forceParentRender = () => forceParentRender();
+(window as any).__method = () => current;
+(window as any).__order = () => orderedViews(current.views).map((v: any) => v.name);

package/tools/tests/tis-editor.test.mjs

@@ -0,0 +1,133 @@
+/**
+ * TIS-editor regression test — run with `npm run test:tis-editor`.
+ *
+ * Covers two things that have no other guard:
+ *
+ *  1. An open dialog keeps the operator's edits across re-renders of the tree
+ *     above it. The editors live under `AutoCoreTagProvider`/`TisProvider`,
+ *     whose consumers re-render on live tag and broadcast traffic; a draft
+ *     reseeded on prop identity is wiped a frame after every keystroke, which
+ *     is what made the chart-view dialog read-only on a running machine
+ *     (gen4_ac, 2026-08-29).
+ *  2. Chart views display in the author's `order`, and Move up / Move down
+ *     renumbers it — the server hands `views` back id-sorted, so the order is
+ *     carried per view rather than implied by the map.
+ *
+ * No test framework: jsdom + `react`'s `act`, driving the real components.
+ */
+
+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(){} }));
+dom.window.confirm = () => true;
+
+await import('./dist/tis-editor.entry.js');
+const { act } = await import('react');
+
+const tick = async () => { await act(async () => { await new Promise(r => setTimeout(r, 20)); }); };
+
+await act(async () => { window.__mount(); });
+await tick();
+
+const q = (sel) => [...document.querySelectorAll(sel)];
+const rowIds = () => [...q('tbody')[0].querySelectorAll('tr')].map(tr => tr.querySelector('td')?.textContent);
+const rowButtons = (row) => [...q('tbody')[0].querySelectorAll('tr')[row].querySelectorAll('button')];
+const byLabel = (row, label) => rowButtons(row).find(b => b.getAttribute('aria-label') === label);
+const dialog = () => q('.p-dialog').at(-1);
+const inputs = () => [...dialog().querySelectorAll('input')];
+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 check = (name, got, want) => {
+    const ok = JSON.stringify(got) === JSON.stringify(want);
+    console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}: ${JSON.stringify(got)}${ok ? '' : '  want ' + JSON.stringify(want)}`);
+    if (!ok) process.exitCode = 1;
+};
+
+check('initial row order (id order, no `order` keys)', rowIds(), ['load_vs_deflection', 'peak_load_by_cycle']);
+
+// ---- 1. edit an existing view, then force a parent re-render mid-edit
+await act(async () => { byLabel(1, 'Edit').click(); });
+await tick();
+const titleInput = inputs()[1];
+check('dialog seeded from the edited view', titleInput.value, 'Peak Load by Cycle');
+
+await act(async () => { setValue(titleInput, 'Deflection by Cycle'); });
+await tick();
+check('typing lands', inputs()[1].value, 'Deflection by Cycle');
+
+for (let i = 0; i < 5; i++) { await act(async () => { window.__forceParentRender(); }); await tick(); }
+check('survives 5 parent re-renders', inputs()[1].value, 'Deflection by Cycle');
+
+// also edit the Y series field, then re-render again
+const yField = inputs().find(el => el.value === 'peak_load' && el.placeholder === 'field');
+await act(async () => { setValue(yField, 'deflection'); });
+await tick();
+await act(async () => { window.__forceParentRender(); });
+await tick();
+check('series edit survives too', inputs().find(el => el.placeholder === 'field').value, 'deflection');
+
+// Save
+await act(async () => { [...dialog().querySelectorAll('button')].find(b => b.textContent.includes('Save')).click(); });
+await tick();
+const saved = window.__method().views.peak_load_by_cycle;
+check('saved title', saved.title, 'Deflection by Cycle');
+check('saved series field', saved.y[0].field, 'deflection');
+
+// ---- 2. reorder
+await act(async () => { byLabel(1, 'Move up').click(); });
+await tick();
+check('row order after Move up', rowIds(), ['peak_load_by_cycle', 'load_vs_deflection']);
+check('order keys are dense', Object.fromEntries(Object.entries(window.__method().views).map(([k, v]) => [k, v.order])), { peak_load_by_cycle: 0, load_vs_deflection: 1 });
+check('runtime picker agrees', window.__order(), ['peak_load_by_cycle', 'load_vs_deflection']);
+
+// Move-up on the first row is disabled; move the first row down again
+check('first row Move up disabled', byLabel(0, 'Move up').disabled, true);
+check('last row Move down disabled', byLabel(1, 'Move down').disabled, true);
+await act(async () => { byLabel(0, 'Move down').click(); });
+await tick();
+check('row order after Move down', rowIds(), ['load_vs_deflection', 'peak_load_by_cycle']);
+
+// ---- 3. a new view lands last, not first
+await act(async () => { [...document.querySelectorAll('button')].find(b => b.textContent.includes('Add view')).click(); });
+await tick();
+await act(async () => { setValue(inputs()[0], 'aaa_new_view'); });
+await tick();
+await act(async () => { window.__forceParentRender(); });
+await tick();
+check('new-view id survives a re-render', inputs()[0].value, 'aaa_new_view');
+await act(async () => { [...dialog().querySelectorAll('button')].find(b => b.textContent.includes('Save')).click(); });
+await tick();
+check('new view sorts last despite its id', rowIds(), ['load_vs_deflection', 'peak_load_by_cycle', 'aaa_new_view']);
+
+// ---- 4. the field dialog (same reseed class) — second DataTable on the page
+const fieldRows = () => [...q('tbody')[1].querySelectorAll('tr')];
+const fieldBtn = (row, label) => [...fieldRows()[row].querySelectorAll('button')].find(b => b.getAttribute('aria-label') === label);
+check('field rows', fieldRows().map(tr => tr.querySelector('td')?.textContent), ['peak_load', 'deflection']);
+await act(async () => { fieldBtn(0, 'Edit').click(); });
+await tick();
+const nameInput = inputs()[0];
+check('field dialog seeded', nameInput.value, 'peak_load');
+await act(async () => { setValue(nameInput, 'peak_load_n'); });
+await tick();
+for (let i = 0; i < 5; i++) { await act(async () => { window.__forceParentRender(); }); await tick(); }
+check('field edit survives parent re-renders', inputs()[0].value, 'peak_load_n');

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,
+};