onbuzz 4.9.13 → 4.10.0

package/src/utilities/__tests__/toolConstants.test.js

@@ -1,94 +1,92 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import {
-  TOOL_IDS,
-  identifyJsonStructure,
-  getToolIdFromAction,
-  isValidToolId,
-  getToolActions,
-  TOOL_ACTION_MAP,
-  JSON_STRUCTURES,
-  COMMAND_FORMATS
-} from '../toolConstants.js';
-
-describe('toolConstants', () => {
-  beforeEach(() => {
-    jest.spyOn(console, 'warn').mockImplementation(() => {});
-  });
-
-  describe('TOOL_IDS', () => {
-    test('contains expected tool IDs', () => {
-      expect(TOOL_IDS.TERMINAL).toBe('terminal');
-      expect(TOOL_IDS.FILESYSTEM).toBe('filesystem');
-      expect(TOOL_IDS.WEB).toBe('web');
-      expect(TOOL_IDS.JOB_DONE).toBe('jobdone');
-      expect(TOOL_IDS.TASK_MANAGER).toBe('taskmanager');
-      expect(TOOL_IDS.AGENT_COMMUNICATION).toBe('agentcommunication');
-    });
-  });
-
-  describe('isValidToolId', () => {
-    test('returns true for known tools, false for unknown', () => {
-      expect(isValidToolId('terminal')).toBe(true);
-      expect(isValidToolId('filesystem')).toBe(true);
-      expect(isValidToolId('web')).toBe(true);
-      expect(isValidToolId('nonexistent-tool')).toBe(false);
-      expect(isValidToolId('')).toBe(false);
-      expect(isValidToolId(null)).toBe(false);
-    });
-  });
-
-  describe('getToolIdFromAction', () => {
-    test('returns correct tool for known actions', () => {
-      expect(getToolIdFromAction('run-command')).toBe('terminal');
-      expect(getToolIdFromAction('write-file')).toBe('filesystem');
-      expect(getToolIdFromAction('move-file')).toBe('filesystem');
-      // Note: 'read-file' is overridden by skills tool in TOOL_ACTION_MAP
-      expect(getToolIdFromAction('read-file')).toBe('skills');
-      expect(getToolIdFromAction('delay')).toBe('agentdelay');
-    });
-
-    test('returns null for unknown action', () => {
-      expect(getToolIdFromAction('totally-unknown-action')).toBeNull();
-      expect(getToolIdFromAction(null)).toBeNull();
-      expect(getToolIdFromAction('')).toBeNull();
-    });
-  });
-
-  describe('identifyJsonStructure', () => {
-    test('identifies standard format { toolId, parameters }', () => {
-      const data = { toolId: 'terminal', parameters: { command: 'ls' } };
-      expect(identifyJsonStructure(data)).toBe(JSON_STRUCTURES.STANDARD);
-    });
-
-    test('identifies actions array format', () => {
-      const data = { actions: [{ type: 'run-command' }] };
-      expect(identifyJsonStructure(data)).toBe(JSON_STRUCTURES.ACTIONS_ARRAY);
-    });
-
-    test('identifies direct action format', () => {
-      const data = { type: 'run-command', command: 'ls' };
-      expect(identifyJsonStructure(data)).toBe(JSON_STRUCTURES.DIRECT_ACTION);
-    });
-
-    test('returns null for non-object or unrecognized input', () => {
-      expect(identifyJsonStructure(null)).toBeNull();
-      expect(identifyJsonStructure('string')).toBeNull();
-      expect(identifyJsonStructure({ random: 'data' })).toBeNull();
-    });
-  });
-
-  describe('getToolActions', () => {
-    test('returns array of actions for a valid tool', () => {
-      const terminalActions = getToolActions('terminal');
-      expect(Array.isArray(terminalActions)).toBe(true);
-      expect(terminalActions).toContain('run-command');
-      expect(terminalActions).toContain('change-directory');
-      expect(terminalActions.length).toBeGreaterThan(0);
-    });
-
-    test('returns empty array for unknown tool', () => {
-      const actions = getToolActions('nonexistent-tool');
-      expect(actions).toEqual([]);
-    });
-  });
-});
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import {
+  TOOL_IDS,
+  identifyJsonStructure,
+  getToolIdFromAction,
+  isValidToolId,
+  getToolActions,
+  JSON_STRUCTURES
+} from '../toolConstants.js';
+
+describe('toolConstants', () => {
+  beforeEach(() => {
+    jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  describe('TOOL_IDS', () => {
+    test('contains expected tool IDs', () => {
+      expect(TOOL_IDS.TERMINAL).toBe('terminal');
+      expect(TOOL_IDS.FILESYSTEM).toBe('filesystem');
+      expect(TOOL_IDS.WEB).toBe('web');
+      expect(TOOL_IDS.JOB_DONE).toBe('jobdone');
+      expect(TOOL_IDS.TASK_MANAGER).toBe('taskmanager');
+      expect(TOOL_IDS.AGENT_COMMUNICATION).toBe('agentcommunication');
+    });
+  });
+
+  describe('isValidToolId', () => {
+    test('returns true for known tools, false for unknown', () => {
+      expect(isValidToolId('terminal')).toBe(true);
+      expect(isValidToolId('filesystem')).toBe(true);
+      expect(isValidToolId('web')).toBe(true);
+      expect(isValidToolId('nonexistent-tool')).toBe(false);
+      expect(isValidToolId('')).toBe(false);
+      expect(isValidToolId(null)).toBe(false);
+    });
+  });
+
+  describe('getToolIdFromAction', () => {
+    test('returns correct tool for known actions', () => {
+      expect(getToolIdFromAction('run-command')).toBe('terminal');
+      expect(getToolIdFromAction('write-file')).toBe('filesystem');
+      expect(getToolIdFromAction('move-file')).toBe('filesystem');
+      // Note: 'read-file' is overridden by skills tool in TOOL_ACTION_MAP
+      expect(getToolIdFromAction('read-file')).toBe('skills');
+      expect(getToolIdFromAction('delay')).toBe('agentdelay');
+    });
+
+    test('returns null for unknown action', () => {
+      expect(getToolIdFromAction('totally-unknown-action')).toBeNull();
+      expect(getToolIdFromAction(null)).toBeNull();
+      expect(getToolIdFromAction('')).toBeNull();
+    });
+  });
+
+  describe('identifyJsonStructure', () => {
+    test('identifies standard format { toolId, parameters }', () => {
+      const data = { toolId: 'terminal', parameters: { command: 'ls' } };
+      expect(identifyJsonStructure(data)).toBe(JSON_STRUCTURES.STANDARD);
+    });
+
+    test('identifies actions array format', () => {
+      const data = { actions: [{ type: 'run-command' }] };
+      expect(identifyJsonStructure(data)).toBe(JSON_STRUCTURES.ACTIONS_ARRAY);
+    });
+
+    test('identifies direct action format', () => {
+      const data = { type: 'run-command', command: 'ls' };
+      expect(identifyJsonStructure(data)).toBe(JSON_STRUCTURES.DIRECT_ACTION);
+    });
+
+    test('returns null for non-object or unrecognized input', () => {
+      expect(identifyJsonStructure(null)).toBeNull();
+      expect(identifyJsonStructure('string')).toBeNull();
+      expect(identifyJsonStructure({ random: 'data' })).toBeNull();
+    });
+  });
+
+  describe('getToolActions', () => {
+    test('returns array of actions for a valid tool', () => {
+      const terminalActions = getToolActions('terminal');
+      expect(Array.isArray(terminalActions)).toBe(true);
+      expect(terminalActions).toContain('run-command');
+      expect(terminalActions).toContain('change-directory');
+      expect(terminalActions.length).toBeGreaterThan(0);
+    });
+
+    test('returns empty array for unknown tool', () => {
+      const actions = getToolActions('nonexistent-tool');
+      expect(actions).toEqual([]);
+    });
+  });
+});

package/src/utilities/__tests__/useIsTouchDevice.detect.test.js

@@ -1,114 +1,114 @@
-/**
- * Tests for the touch-device detection logic that lives inside the
- * `useIsTouchDevice` hook (extracted as a pure function below for unit
- * testability — the hook itself wraps it with React state + a media-
- * query subscription).
- *
- * Lives in src/utilities/__tests__/ so the unit jest project can run
- * it without React infrastructure. The actual hook (web-ui/src/hooks/
- * useIsTouchDevice.js) is a thin wrapper around the same detection
- * rules — keep them in sync.
- *
- * Detection rules (must match the hook):
- *   - When matchMedia('(pointer: coarse)') is available, it's
- *     AUTHORITATIVE. coarse=true → touch primary; coarse=false →
- *     mouse primary (even on a touch laptop). This prevents tap-mode
- *     from kicking in on a 2-in-1 with a mouse plugged in.
- *   - When matchMedia is unavailable OR throws, fall through to:
- *       1. 'ontouchstart' in window → true
- *       2. navigator.maxTouchPoints > 0 → true
- *       3. otherwise → false
- */
-import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
-
-// Re-implementing the rule here keeps the test independent of the
-// React import. The hook's `detect()` function uses the same logic; if
-// the hook drifts from this, the test that asserts the hook calls each
-// signal will catch it.
-function detectFromGlobals(win, nav) {
-  if (!win) return false;
-  if (typeof win.matchMedia === 'function') {
-    try {
-      const mql = win.matchMedia('(pointer: coarse)');
-      return !!mql.matches;
-    } catch { /* matchMedia threw — fall through to legacy signals */ }
-  }
-  if ('ontouchstart' in win) return true;
-  if (nav && typeof nav.maxTouchPoints === 'number' && nav.maxTouchPoints > 0) return true;
-  return false;
-}
-
-describe('detectFromGlobals (touch detection rules)', () => {
-  test('returns false in a server-rendered context (no window)', () => {
-    expect(detectFromGlobals(null, null)).toBe(false);
-    expect(detectFromGlobals(undefined, undefined)).toBe(false);
-  });
-
-  test('matchMedia(pointer: coarse) match → true (primary signal)', () => {
-    const win = {
-      matchMedia: (q) => ({ matches: q === '(pointer: coarse)' }),
-    };
-    expect(detectFromGlobals(win, {})).toBe(true);
-  });
-
-  test('matchMedia(pointer: coarse) no match is authoritative — does NOT fall through', () => {
-    // Even with ontouchstart present, a pointer:coarse=false says "user
-    // has precise input" (mouse / trackpad on a touch laptop) — UI
-    // shouldn\'t switch to tap mode.
-    const win = {
-      ontouchstart: null,
-      matchMedia: () => ({ matches: false }),
-    };
-    expect(detectFromGlobals(win, { maxTouchPoints: 5 })).toBe(false);
-  });
-
-  test('matchMedia absent → falls through to ontouchstart fallback', () => {
-    const win = { ontouchstart: null };  // no matchMedia
-    expect(detectFromGlobals(win, {})).toBe(true);
-  });
-
-  test('ontouchstart present → true (fallback for older browsers)', () => {
-    const win = { ontouchstart: null };
-    expect(detectFromGlobals(win, {})).toBe(true);
-  });
-
-  test('navigator.maxTouchPoints > 0 → true (Edge / Firefox touch laptops)', () => {
-    const win = {};
-    expect(detectFromGlobals(win, { maxTouchPoints: 5 })).toBe(true);
-  });
-
-  test('navigator.maxTouchPoints === 0 → false', () => {
-    expect(detectFromGlobals({}, { maxTouchPoints: 0 })).toBe(false);
-  });
-
-  test('matchMedia throwing does not crash detection (Safari iOS 12 quirk)', () => {
-    const win = {
-      matchMedia: () => { throw new Error('not supported'); },
-    };
-    // Falls through cleanly — should report false (no ontouchstart, no maxTouchPoints).
-    expect(detectFromGlobals(win, {})).toBe(false);
-  });
-
-  test('priority: pointer-coarse wins over ontouchstart (laptop with both)', () => {
-    // A 2-in-1 with a mouse plugged in: ontouchstart present, but
-    // pointer:coarse is FALSE (mouse is the primary). Should report false.
-    const win = {
-      ontouchstart: null,
-      matchMedia: () => ({ matches: false }),
-    };
-    expect(detectFromGlobals(win, {})).toBe(false);
-  });
-
-  test('priority: pointer-coarse wins over both fallbacks', () => {
-    const win = {
-      ontouchstart: null,
-      matchMedia: () => ({ matches: true }),
-    };
-    expect(detectFromGlobals(win, { maxTouchPoints: 0 })).toBe(true);
-  });
-});
-
-// The hook also exposes the active runs filter via flowRunFilters
-// (separate test file). Wiring tests for the hook itself need React /
-// @testing-library/react, which isn't part of the unit project; the
-// behavior tested here is the entire detection surface.
+/**
+ * Tests for the touch-device detection logic that lives inside the
+ * `useIsTouchDevice` hook (extracted as a pure function below for unit
+ * testability — the hook itself wraps it with React state + a media-
+ * query subscription).
+ *
+ * Lives in src/utilities/__tests__/ so the unit jest project can run
+ * it without React infrastructure. The actual hook (web-ui/src/hooks/
+ * useIsTouchDevice.js) is a thin wrapper around the same detection
+ * rules — keep them in sync.
+ *
+ * Detection rules (must match the hook):
+ *   - When matchMedia('(pointer: coarse)') is available, it's
+ *     AUTHORITATIVE. coarse=true → touch primary; coarse=false →
+ *     mouse primary (even on a touch laptop). This prevents tap-mode
+ *     from kicking in on a 2-in-1 with a mouse plugged in.
+ *   - When matchMedia is unavailable OR throws, fall through to:
+ *       1. 'ontouchstart' in window → true
+ *       2. navigator.maxTouchPoints > 0 → true
+ *       3. otherwise → false
+ */
+import { describe, test, expect } from '@jest/globals';
+
+// Re-implementing the rule here keeps the test independent of the
+// React import. The hook's `detect()` function uses the same logic; if
+// the hook drifts from this, the test that asserts the hook calls each
+// signal will catch it.
+function detectFromGlobals(win, nav) {
+  if (!win) return false;
+  if (typeof win.matchMedia === 'function') {
+    try {
+      const mql = win.matchMedia('(pointer: coarse)');
+      return !!mql.matches;
+    } catch { /* matchMedia threw — fall through to legacy signals */ }
+  }
+  if ('ontouchstart' in win) return true;
+  if (nav && typeof nav.maxTouchPoints === 'number' && nav.maxTouchPoints > 0) return true;
+  return false;
+}
+
+describe('detectFromGlobals (touch detection rules)', () => {
+  test('returns false in a server-rendered context (no window)', () => {
+    expect(detectFromGlobals(null, null)).toBe(false);
+    expect(detectFromGlobals(undefined, undefined)).toBe(false);
+  });
+
+  test('matchMedia(pointer: coarse) match → true (primary signal)', () => {
+    const win = {
+      matchMedia: (q) => ({ matches: q === '(pointer: coarse)' }),
+    };
+    expect(detectFromGlobals(win, {})).toBe(true);
+  });
+
+  test('matchMedia(pointer: coarse) no match is authoritative — does NOT fall through', () => {
+    // Even with ontouchstart present, a pointer:coarse=false says "user
+    // has precise input" (mouse / trackpad on a touch laptop) — UI
+    // shouldn\'t switch to tap mode.
+    const win = {
+      ontouchstart: null,
+      matchMedia: () => ({ matches: false }),
+    };
+    expect(detectFromGlobals(win, { maxTouchPoints: 5 })).toBe(false);
+  });
+
+  test('matchMedia absent → falls through to ontouchstart fallback', () => {
+    const win = { ontouchstart: null };  // no matchMedia
+    expect(detectFromGlobals(win, {})).toBe(true);
+  });
+
+  test('ontouchstart present → true (fallback for older browsers)', () => {
+    const win = { ontouchstart: null };
+    expect(detectFromGlobals(win, {})).toBe(true);
+  });
+
+  test('navigator.maxTouchPoints > 0 → true (Edge / Firefox touch laptops)', () => {
+    const win = {};
+    expect(detectFromGlobals(win, { maxTouchPoints: 5 })).toBe(true);
+  });
+
+  test('navigator.maxTouchPoints === 0 → false', () => {
+    expect(detectFromGlobals({}, { maxTouchPoints: 0 })).toBe(false);
+  });
+
+  test('matchMedia throwing does not crash detection (Safari iOS 12 quirk)', () => {
+    const win = {
+      matchMedia: () => { throw new Error('not supported'); },
+    };
+    // Falls through cleanly — should report false (no ontouchstart, no maxTouchPoints).
+    expect(detectFromGlobals(win, {})).toBe(false);
+  });
+
+  test('priority: pointer-coarse wins over ontouchstart (laptop with both)', () => {
+    // A 2-in-1 with a mouse plugged in: ontouchstart present, but
+    // pointer:coarse is FALSE (mouse is the primary). Should report false.
+    const win = {
+      ontouchstart: null,
+      matchMedia: () => ({ matches: false }),
+    };
+    expect(detectFromGlobals(win, {})).toBe(false);
+  });
+
+  test('priority: pointer-coarse wins over both fallbacks', () => {
+    const win = {
+      ontouchstart: null,
+      matchMedia: () => ({ matches: true }),
+    };
+    expect(detectFromGlobals(win, { maxTouchPoints: 0 })).toBe(true);
+  });
+});
+
+// The hook also exposes the active runs filter via flowRunFilters
+// (separate test file). Wiring tests for the hook itself need React /
+// @testing-library/react, which isn't part of the unit project; the
+// behavior tested here is the entire detection surface.

package/src/utilities/__tests__/webUiUtilSync.test.js

@@ -1,117 +1,117 @@
-/**
- * Sync-guard for vendored web-ui copies of server-side helpers.
- *
- * Two helpers exist in BOTH `src/utilities/` (server-side, under unit
- * tests) AND `web-ui/src/utils/` (vendored copy bundled by Vite).
- * We keep two copies because the Docker build context is `web-ui/`
- * only — cross-tree imports from `../../../src/...` worked locally
- * but broke production builds.
- *
- * The two copies must stay BEHAVIORALLY identical. This test imports
- * both copies and exercises them on the same fixtures, asserting the
- * outputs match. If they diverge, this test fails loudly; whoever
- * changed one was supposed to change the other.
- *
- * The path-based dynamic import bypasses the unit jest project's
- * `/web-ui/` testPathIgnorePattern (we're not running web-ui tests,
- * we're just importing modules from the web-ui tree to compare them).
- */
-import { describe, test, expect, beforeAll } from '@jest/globals';
-
-// Server-side originals.
-import * as srvEdgeIds  from '../flowEdgeIds.js';
-import * as srvPublish  from '../flowPublish.js';
-
-// Vendored web-ui copies. Plain relative imports — jest's
-// testPathIgnorePatterns gates which TEST FILES run (not which modules
-// can be imported by other tests), so importing from web-ui/ is fine.
-import * as webUiEdgeIds from '../../../web-ui/src/utils/flowEdgeIds.js';
-import * as webUiPublish from '../../../web-ui/src/utils/flowPublish.js';
-
-// Fixtures exercising both helpers' interesting branches.
-const edgeFixtures = [
-  [],
-  null,
-  undefined,
-  'not-an-array',
-  [{ source: 'a', target: 'b' }],
-  [{ source: 'a', sourceField: 'topic', target: 'b', targetField: 'topic' }],
-  [{ id: 'pre-existing-id', source: 'a', target: 'b' }],
-  [
-    { source: 'a', target: 'b' },
-    { source: 'a', target: 'b' },                  // duplicate — needs index tiebreaker
-    { id: 'kept', source: 'c', target: 'd' },
-  ],
-  [null, { source: 'x', target: 'y' }, undefined],
-];
-
-const flowFixtures = [
-  null,
-  undefined,
-  'not-an-object',
-  { nodes: [], edges: [] },
-  {
-    schemaVersion: 2,
-    description: 'A '.repeat(200),
-    nodes: [
-      { id: 'in',  type: 'input' },
-      { id: 'a',   type: 'agent', data: { agentId: 'agent-real-id', model: 'gpt-5', label: 'A' } },
-      { id: 'b',   type: 'agent', data: { agentId: 'another-id', preferredModel: 'kimi' } },
-      { id: 'p',   type: 'pause' },
-      { id: 'cron',type: 'agent', data: { cron: '0 9 * * *' } },
-      { id: 'out', type: 'output' },
-    ],
-    edges: [{ source: 'in', target: 'a' }, { source: 'a', target: 'b' }],
-  },
-];
-
-describe('flowEdgeIds — server vs web-ui copy', () => {
-  test('exports the same surface', () => {
-    expect(typeof webUiEdgeIds.makeEdgeId).toBe('function');
-    expect(typeof webUiEdgeIds.ensureEdgeIds).toBe('function');
-  });
-
-  test('makeEdgeId outputs match for every fixture edge', () => {
-    const cases = [
-      [{ source: 'a', target: 'b' }, 0],
-      [{ source: 'a', sourceField: 'x', target: 'b', targetField: 'y' }, 7],
-      [{}, 0],
-      [null, 5],
-      [{ source: 'with:colons', target: 'b' }, 0],
-    ];
-    for (const [edge, idx] of cases) {
-      expect(webUiEdgeIds.makeEdgeId(edge, idx)).toBe(srvEdgeIds.makeEdgeId(edge, idx));
-    }
-  });
-
-  test('ensureEdgeIds outputs match for every fixture array', () => {
-    for (const fixture of edgeFixtures) {
-      const a = srvEdgeIds.ensureEdgeIds(fixture);
-      const b = webUiEdgeIds.ensureEdgeIds(fixture);
-      expect(b).toEqual(a);
-    }
-  });
-});
-
-describe('flowPublish — server vs web-ui copy', () => {
-  test('exports the same surface', () => {
-    expect(typeof webUiPublish.computeFlowPublishMetadata).toBe('function');
-    expect(typeof webUiPublish.sanitizeFlowForPublish).toBe('function');
-  });
-
-  test('computeFlowPublishMetadata outputs match for every fixture flow', () => {
-    for (const flow of flowFixtures) {
-      const a = srvPublish.computeFlowPublishMetadata(flow);
-      const b = webUiPublish.computeFlowPublishMetadata(flow);
-      expect(b).toEqual(a);
-    }
-  });
-
-  test('sanitizeFlowForPublish outputs match for every fixture flow', () => {
-    for (const flow of flowFixtures) {
-      const a = srvPublish.sanitizeFlowForPublish(flow);
-      const b = webUiPublish.sanitizeFlowForPublish(flow);
-      expect(b).toEqual(a);
-    }
-  });
-});
+/**
+ * Sync-guard for vendored web-ui copies of server-side helpers.
+ *
+ * Two helpers exist in BOTH `src/utilities/` (server-side, under unit
+ * tests) AND `web-ui/src/utils/` (vendored copy bundled by Vite).
+ * We keep two copies because the Docker build context is `web-ui/`
+ * only — cross-tree imports from `../../../src/...` worked locally
+ * but broke production builds.
+ *
+ * The two copies must stay BEHAVIORALLY identical. This test imports
+ * both copies and exercises them on the same fixtures, asserting the
+ * outputs match. If they diverge, this test fails loudly; whoever
+ * changed one was supposed to change the other.
+ *
+ * The path-based dynamic import bypasses the unit jest project's
+ * `/web-ui/` testPathIgnorePattern (we're not running web-ui tests,
+ * we're just importing modules from the web-ui tree to compare them).
+ */
+import { describe, test, expect } from '@jest/globals';
+
+// Server-side originals.
+import * as srvEdgeIds  from '../flowEdgeIds.js';
+import * as srvPublish  from '../flowPublish.js';
+
+// Vendored web-ui copies. Plain relative imports — jest's
+// testPathIgnorePatterns gates which TEST FILES run (not which modules
+// can be imported by other tests), so importing from web-ui/ is fine.
+import * as webUiEdgeIds from '../../../web-ui/src/utils/flowEdgeIds.js';
+import * as webUiPublish from '../../../web-ui/src/utils/flowPublish.js';
+
+// Fixtures exercising both helpers' interesting branches.
+const edgeFixtures = [
+  [],
+  null,
+  undefined,
+  'not-an-array',
+  [{ source: 'a', target: 'b' }],
+  [{ source: 'a', sourceField: 'topic', target: 'b', targetField: 'topic' }],
+  [{ id: 'pre-existing-id', source: 'a', target: 'b' }],
+  [
+    { source: 'a', target: 'b' },
+    { source: 'a', target: 'b' },                  // duplicate — needs index tiebreaker
+    { id: 'kept', source: 'c', target: 'd' },
+  ],
+  [null, { source: 'x', target: 'y' }, undefined],
+];
+
+const flowFixtures = [
+  null,
+  undefined,
+  'not-an-object',
+  { nodes: [], edges: [] },
+  {
+    schemaVersion: 2,
+    description: 'A '.repeat(200),
+    nodes: [
+      { id: 'in',  type: 'input' },
+      { id: 'a',   type: 'agent', data: { agentId: 'agent-real-id', model: 'gpt-5', label: 'A' } },
+      { id: 'b',   type: 'agent', data: { agentId: 'another-id', preferredModel: 'kimi' } },
+      { id: 'p',   type: 'pause' },
+      { id: 'cron',type: 'agent', data: { cron: '0 9 * * *' } },
+      { id: 'out', type: 'output' },
+    ],
+    edges: [{ source: 'in', target: 'a' }, { source: 'a', target: 'b' }],
+  },
+];
+
+describe('flowEdgeIds — server vs web-ui copy', () => {
+  test('exports the same surface', () => {
+    expect(typeof webUiEdgeIds.makeEdgeId).toBe('function');
+    expect(typeof webUiEdgeIds.ensureEdgeIds).toBe('function');
+  });
+
+  test('makeEdgeId outputs match for every fixture edge', () => {
+    const cases = [
+      [{ source: 'a', target: 'b' }, 0],
+      [{ source: 'a', sourceField: 'x', target: 'b', targetField: 'y' }, 7],
+      [{}, 0],
+      [null, 5],
+      [{ source: 'with:colons', target: 'b' }, 0],
+    ];
+    for (const [edge, idx] of cases) {
+      expect(webUiEdgeIds.makeEdgeId(edge, idx)).toBe(srvEdgeIds.makeEdgeId(edge, idx));
+    }
+  });
+
+  test('ensureEdgeIds outputs match for every fixture array', () => {
+    for (const fixture of edgeFixtures) {
+      const a = srvEdgeIds.ensureEdgeIds(fixture);
+      const b = webUiEdgeIds.ensureEdgeIds(fixture);
+      expect(b).toEqual(a);
+    }
+  });
+});
+
+describe('flowPublish — server vs web-ui copy', () => {
+  test('exports the same surface', () => {
+    expect(typeof webUiPublish.computeFlowPublishMetadata).toBe('function');
+    expect(typeof webUiPublish.sanitizeFlowForPublish).toBe('function');
+  });
+
+  test('computeFlowPublishMetadata outputs match for every fixture flow', () => {
+    for (const flow of flowFixtures) {
+      const a = srvPublish.computeFlowPublishMetadata(flow);
+      const b = webUiPublish.computeFlowPublishMetadata(flow);
+      expect(b).toEqual(a);
+    }
+  });
+
+  test('sanitizeFlowForPublish outputs match for every fixture flow', () => {
+    for (const flow of flowFixtures) {
+      const a = srvPublish.sanitizeFlowForPublish(flow);
+      const b = webUiPublish.sanitizeFlowForPublish(flow);
+      expect(b).toEqual(a);
+    }
+  });
+});