sdlc-agent-4-enterprise-server 1.0.0

package/src/viewer/__tests__/lod-manager.test.js

@@ -0,0 +1,300 @@
+/**
+ * Unit & Integration Tests for LODManager — KSA-291 Bug Fix
+ * Tests: _getExpandedCentroid, _checkDistances (fixed), _freeBudget (fixed)
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Test Helpers ---
+
+function createMockGraph(cameraPosition = { x: 0, y: 0, z: 0 }) {
+  return {
+    camera: () => ({ position: cameraPosition }),
+    graphData: vi.fn(),
+    nodeVal: vi.fn(),
+    nodeColor: vi.fn(),
+    nodeLabel: vi.fn(),
+  };
+}
+
+function createMockAnimation() {
+  return {
+    isAnimating: vi.fn().mockReturnValue(false),
+    expand: vi.fn(),
+    collapse: vi.fn(),
+    dispose: vi.fn(),
+  };
+}
+
+function createCluster(id, center, childNodeIds, state = 'COLLAPSED') {
+  return {
+    id,
+    label: `Cluster ${id}`,
+    center,
+    childNodeIds,
+    state,
+    interacting: false,
+    dominantType: 'ARCHITECTURE',
+    radius: 25,
+  };
+}
+
+// Since LODManager is a class with private methods, we test via a minimal instance
+// that exposes internals for testing purposes.
+
+class TestableLODManager {
+  constructor(graph, config = {}) {
+    this._graph = graph;
+    this._config = {
+      expandThreshold: config.expandThreshold || 50,
+      collapseThreshold: config.collapseThreshold || (config.expandThreshold || 50) * 1.4,
+      animationDuration: config.animationDuration || 400,
+      maxVisibleNodes: config.maxVisibleNodes || 100,
+    };
+    this._clusters = new Map();
+    this._allNodes = [];
+    this._allEdges = [];
+    this._visibleNodes = new Set();
+    this._animation = createMockAnimation();
+    this._initialized = true;
+  }
+
+  _getExpandedCentroid(cluster) {
+    const childNodes = this._getChildNodes(cluster);
+    if (childNodes.length === 0) return cluster.center;
+    let sumX = 0, sumY = 0, sumZ = 0;
+    const len = childNodes.length;
+    for (let i = 0; i < len; i++) {
+      sumX += childNodes[i].x || 0;
+      sumY += childNodes[i].y || 0;
+      sumZ += childNodes[i].z || 0;
+    }
+    return { x: sumX / len, y: sumY / len, z: sumZ / len };
+  }
+
+  _checkDistances() {
+    const cam = this._graph.camera().position;
+    for (const [id, cluster] of this._clusters) {
+      if (this._animation.isAnimating(id)) continue;
+
+      if (cluster.state === 'COLLAPSED') {
+        const dist = this._distance(cam, cluster.center);
+        if (dist < this._config.expandThreshold) {
+          if (this._budgetAllows(cluster)) this.expandCluster(id);
+        }
+      } else if (cluster.state === 'EXPANDED') {
+        const centroid = this._getExpandedCentroid(cluster);
+        const dist = this._distance(cam, centroid);
+        if (dist > this._config.collapseThreshold) {
+          if (!cluster.interacting) this.collapseCluster(id);
+        }
+      }
+    }
+  }
+
+  _freeBudget(needed) {
+    const cam = this._graph.camera().position;
+    const expanded = Array.from(this._clusters.values())
+      .filter(c => c.state === 'EXPANDED' && !c.interacting)
+      .sort((a, b) => {
+        const distA = this._distance(cam, this._getExpandedCentroid(a));
+        const distB = this._distance(cam, this._getExpandedCentroid(b));
+        return distB - distA;
+      });
+    for (const cluster of expanded) {
+      this.collapseCluster(cluster.id);
+      if (this._visibleNodes.size - 1 + needed <= this._config.maxVisibleNodes) return true;
+    }
+    return false;
+  }
+
+  _budgetAllows(cluster) {
+    return (this._visibleNodes.size - 1 + cluster.childNodeIds.length) <= this._config.maxVisibleNodes;
+  }
+
+  _getChildNodes(cluster) {
+    const nodeMap = new Map(this._allNodes.map(n => [n.id, n]));
+    return cluster.childNodeIds.map(id => nodeMap.get(id)).filter(Boolean);
+  }
+
+  _distance(a, b) {
+    const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  expandCluster = vi.fn().mockReturnValue(true);
+  collapseCluster = vi.fn().mockReturnValue(true);
+}
+
+// --- Tests ---
+
+describe('LODManager — KSA-291 Bug Fix', () => {
+  describe('_getExpandedCentroid', () => {
+    it('UT-1: returns correct average for 3 nodes', () => {
+      const graph = createMockGraph();
+      const mgr = new TestableLODManager(graph);
+      mgr._allNodes = [
+        { id: 'n1', x: 0, y: 0, z: 0 },
+        { id: 'n2', x: 10, y: 0, z: 0 },
+        { id: 'n3', x: 20, y: 0, z: 0 },
+      ];
+      const cluster = createCluster('c1', { x: 5, y: 0, z: 0 }, ['n1', 'n2', 'n3'], 'EXPANDED');
+
+      const centroid = mgr._getExpandedCentroid(cluster);
+
+      expect(centroid).toEqual({ x: 10, y: 0, z: 0 });
+    });
+
+    it('UT-2: returns cluster.center when no children found', () => {
+      const graph = createMockGraph();
+      const mgr = new TestableLODManager(graph);
+      mgr._allNodes = [];
+      const cluster = createCluster('c1', { x: 5, y: 5, z: 5 }, ['nonexistent'], 'EXPANDED');
+
+      const centroid = mgr._getExpandedCentroid(cluster);
+
+      expect(centroid).toEqual({ x: 5, y: 5, z: 5 });
+    });
+
+    it('UT-3: handles undefined node positions (treats as 0)', () => {
+      const graph = createMockGraph();
+      const mgr = new TestableLODManager(graph);
+      mgr._allNodes = [
+        { id: 'n1', x: 10, y: undefined, z: 5 },
+        { id: 'n2', x: 20, y: 10, z: undefined },
+      ];
+      const cluster = createCluster('c1', { x: 0, y: 0, z: 0 }, ['n1', 'n2'], 'EXPANDED');
+
+      const centroid = mgr._getExpandedCentroid(cluster);
+
+      expect(centroid.x).toBeCloseTo(15);
+      expect(centroid.y).toBeCloseTo(5);
+      expect(centroid.z).toBeCloseTo(2.5);
+    });
+
+    it('UT-4: single node returns that node position', () => {
+      const graph = createMockGraph();
+      const mgr = new TestableLODManager(graph);
+      mgr._allNodes = [{ id: 'n1', x: 5, y: 10, z: 15 }];
+      const cluster = createCluster('c1', { x: 0, y: 0, z: 0 }, ['n1'], 'EXPANDED');
+
+      const centroid = mgr._getExpandedCentroid(cluster);
+
+      expect(centroid).toEqual({ x: 5, y: 10, z: 15 });
+    });
+  });
+
+  describe('_checkDistances (fixed)', () => {
+    it('UT-5: EXPANDED cluster uses dynamic centroid — collapse triggers', () => {
+      const graph = createMockGraph({ x: 0, y: 0, z: 0 });
+      const mgr = new TestableLODManager(graph, { expandThreshold: 50 });
+
+      mgr._allNodes = [
+        { id: 'n1', x: 80, y: 0, z: 0 },
+        { id: 'n2', x: 100, y: 0, z: 0 },
+      ];
+      const cluster = createCluster('c1', { x: 10, y: 0, z: 0 }, ['n1', 'n2'], 'EXPANDED');
+      mgr._clusters.set('c1', cluster);
+
+      mgr._checkDistances();
+
+      // centroid = (90, 0, 0), dist = 90 > 70 (collapseThreshold) -> collapse triggered
+      expect(mgr.collapseCluster).toHaveBeenCalledWith('c1');
+    });
+
+    it('UT-6: COLLAPSED cluster still uses cluster.center for expand', () => {
+      const graph = createMockGraph({ x: 12, y: 0, z: 0 });
+      const mgr = new TestableLODManager(graph, { expandThreshold: 50 });
+
+      mgr._allNodes = [{ id: 'n1', x: 200, y: 0, z: 0 }];
+      const cluster = createCluster('c1', { x: 10, y: 0, z: 0 }, ['n1'], 'COLLAPSED');
+      mgr._clusters.set('c1', cluster);
+      mgr._visibleNodes = new Set(['c1']);
+
+      mgr._checkDistances();
+
+      // dist to cluster.center = 2 < 50 -> expand triggered
+      expect(mgr.expandCluster).toHaveBeenCalledWith('c1');
+    });
+
+    it('UT-7: skips animating clusters', () => {
+      const graph = createMockGraph({ x: 0, y: 0, z: 0 });
+      const mgr = new TestableLODManager(graph);
+
+      const cluster = createCluster('c1', { x: 10, y: 0, z: 0 }, ['n1'], 'EXPANDING');
+      mgr._clusters.set('c1', cluster);
+      mgr._animation.isAnimating.mockReturnValue(true);
+
+      mgr._checkDistances();
+
+      expect(mgr.expandCluster).not.toHaveBeenCalled();
+      expect(mgr.collapseCluster).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('_freeBudget (fixed)', () => {
+    it('UT-8: sorts by dynamic centroid, collapses farthest first', () => {
+      const graph = createMockGraph({ x: 0, y: 0, z: 0 });
+      const mgr = new TestableLODManager(graph, { maxVisibleNodes: 50 });
+
+      mgr._allNodes = [
+        { id: 'a1', x: 10, y: 0, z: 0 },
+        { id: 'b1', x: 50, y: 0, z: 0 },
+        { id: 'c1', x: 200, y: 0, z: 0 },
+      ];
+      const clusterA = createCluster('cA', { x: 5, y: 0, z: 0 }, ['a1'], 'EXPANDED');
+      const clusterB = createCluster('cB', { x: 5, y: 0, z: 0 }, ['b1'], 'EXPANDED');
+      const clusterC = createCluster('cC', { x: 5, y: 0, z: 0 }, ['c1'], 'EXPANDED');
+
+      mgr._clusters.set('cA', clusterA);
+      mgr._clusters.set('cB', clusterB);
+      mgr._clusters.set('cC', clusterC);
+
+      mgr._visibleNodes = new Set(Array.from({ length: 60 }, (_, i) => `node-${i}`));
+
+      mgr._freeBudget(10);
+
+      // clusterC (centroid x=200) should be collapsed first (farthest)
+      expect(mgr.collapseCluster).toHaveBeenCalledWith('cC');
+      expect(mgr.collapseCluster.mock.calls[0][0]).toBe('cC');
+    });
+  });
+
+  describe('Integration: Expand -> Drift -> Collapse', () => {
+    it('IT-1: collapse triggers after child nodes drift away', () => {
+      const graph = createMockGraph({ x: 0, y: 0, z: 0 });
+      const mgr = new TestableLODManager(graph, { expandThreshold: 50 });
+
+      const childIds = Array.from({ length: 10 }, (_, i) => `n${i}`);
+      mgr._allNodes = childIds.map((id, i) => ({
+        id,
+        x: 150 + i * 5,
+        y: 0,
+        z: 0,
+      }));
+
+      const cluster = createCluster('c1', { x: 10, y: 0, z: 0 }, childIds, 'EXPANDED');
+      mgr._clusters.set('c1', cluster);
+
+      mgr._checkDistances();
+
+      // Dynamic centroid ~ (172.5, 0, 0), dist ~ 172.5 > 70 -> collapse
+      expect(mgr.collapseCluster).toHaveBeenCalledWith('c1');
+    });
+
+    it('IT-3: expand regression — collapsed cluster uses fixed center', () => {
+      const graph = createMockGraph({ x: 48, y: 0, z: 0 });
+      const mgr = new TestableLODManager(graph, { expandThreshold: 50 });
+
+      mgr._allNodes = [{ id: 'n1', x: 500, y: 0, z: 0 }];
+      const cluster = createCluster('c1', { x: 50, y: 0, z: 0 }, ['n1'], 'COLLAPSED');
+      mgr._clusters.set('c1', cluster);
+      mgr._visibleNodes = new Set(['c1']);
+
+      mgr._checkDistances();
+
+      // dist to cluster.center = 2 < 50 -> expand triggered (not child pos 500)
+      expect(mgr.expandCluster).toHaveBeenCalledWith('c1');
+    });
+  });
+});

package/src/viewer/admin/camera-physics.js

@@ -0,0 +1,102 @@
+/**
+ * CameraPhysics — Inertia engine with exponential decay.
+ * Provides pan delta calculation and velocity-based inertia for smooth scrolling.
+ * Zero allocations in hot path (pre-allocated result object).
+ */
+(function(global) {
+  'use strict';
+
+  // Tunable constants
+  const FRICTION = 0.92;
+  const MIN_VELOCITY = 0.1;
+  const PAN_SPEED = 2.0;
+  const REFERENCE_DISTANCE = 1000;
+
+  // Pre-allocated result object (zero GC in tick)
+  const _result = { dx: 0, dy: 0, dz: 0 };
+  const _panResult = { x: 0, y: 0 };
+
+  function CameraPhysics(options) {
+    var opts = options || {};
+    this._friction = opts.friction || FRICTION;
+    this._minVelocity = opts.minVelocity || MIN_VELOCITY;
+    this._panSpeed = opts.panSpeed || PAN_SPEED;
+    this._velocityX = 0;
+    this._velocityY = 0;
+    this._velocityZ = 0;
+  }
+
+  /**
+   * Calculate pan delta adjusted for zoom level.
+   * Returns pre-allocated object {x, y} — world-space delta.
+   */
+  CameraPhysics.prototype.applyPanDelta = function(dx, dy, zoomFactor) {
+    var speed = (zoomFactor / REFERENCE_DISTANCE) * this._panSpeed;
+    _panResult.x = -dx * speed;
+    _panResult.y = dy * speed; // Y inverted (screen vs world)
+    return _panResult;
+  };
+
+  /**
+   * Set inertia velocity from gesture end (pixels/ms).
+   */
+  CameraPhysics.prototype.setInertia = function(vx, vy) {
+    this._velocityX = vx;
+    this._velocityY = vy;
+  };
+
+  /**
+   * Set zoom inertia velocity.
+   */
+  CameraPhysics.prototype.setZoomInertia = function(vz) {
+    this._velocityZ = vz;
+  };
+
+  /**
+   * Tick the physics engine. dt in seconds.
+   * Returns pre-allocated {dx, dy, dz} — position delta to apply.
+   * Exponential decay: v *= friction^(dt*60) for frame-rate independence.
+   */
+  CameraPhysics.prototype.tick = function(dt) {
+    var absX = Math.abs(this._velocityX);
+    var absY = Math.abs(this._velocityY);
+    var absZ = Math.abs(this._velocityZ);
+
+    if (absX < this._minVelocity && absY < this._minVelocity && absZ < this._minVelocity) {
+      this._velocityX = 0; this._velocityY = 0; this._velocityZ = 0;
+      _result.dx = 0; _result.dy = 0; _result.dz = 0;
+      return _result;
+    }
+
+    // Frame-rate independent decay
+    var decay = Math.pow(this._friction, dt * 60);
+    this._velocityX *= decay;
+    this._velocityY *= decay;
+    this._velocityZ *= decay;
+
+    _result.dx = this._velocityX * dt;
+    _result.dy = this._velocityY * dt;
+    _result.dz = this._velocityZ * dt;
+    return _result;
+  };
+
+  /**
+   * Returns true if any velocity component is above threshold.
+   */
+  CameraPhysics.prototype.isMoving = function() {
+    return Math.abs(this._velocityX) >= this._minVelocity ||
+           Math.abs(this._velocityY) >= this._minVelocity ||
+           Math.abs(this._velocityZ) >= this._minVelocity;
+  };
+
+  /**
+   * Immediately stop all motion.
+   */
+  CameraPhysics.prototype.stop = function() {
+    this._velocityX = 0;
+    this._velocityY = 0;
+    this._velocityZ = 0;
+  };
+
+  global.CameraPhysics = CameraPhysics;
+})(typeof window !== 'undefined' ? window : this);

package/src/viewer/admin/gesture-fsm.js

@@ -0,0 +1,195 @@
+/**
+ * GestureStateMachine — Classifies pointer input into PAN/PINCH/DRAG/TAP gestures.
+ * States: IDLE, PENDING_TAP, PAN, PINCH, PENDING_DRAG, TAP_UP, DRAG_NODE
+ * Returns GestureEvent objects from handle* methods.
+ */
+(function(global) {
+  'use strict';
+
+  // Tunable constants
+  const PAN_THRESHOLD = 5;
+  const TAP_MAX_DURATION = 200;
+  const DOUBLE_TAP_WINDOW = 300;
+  const DOUBLE_TAP_RADIUS = 20;
+  const DRAG_HOLD_TIME = 200;
+  const VELOCITY_BUFFER_SIZE = 3;
+
+  // Pre-allocated event object (zero-alloc hot path)
+  const _evt = { type: 'none', dx: 0, dy: 0, x: 0, y: 0, velocityX: 0, velocityY: 0, scale: 0, centerX: 0, centerY: 0, nodeId: null };
+
+  function _emitNone() { _evt.type = 'none'; return _evt; }
+
+  function _dist(x1, y1, x2, y2) {
+    var dx = x2 - x1, dy = y2 - y1;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+
+  function GestureStateMachine(options) {
+    this._state = 'IDLE';
+    this._options = options || {};
+    this._startX = 0; this._startY = 0; this._startTime = 0;
+    this._lastX = 0; this._lastY = 0; this._lastTime = 0;
+    this._prevTapX = 0; this._prevTapY = 0; this._prevTapTime = 0;
+    this._holdTimer = null;
+    this._doubleTapTimer = null;
+    this._pointerCount = 0;
+    this._pinchStartDist = 0;
+    this._pinchCenterX = 0; this._pinchCenterY = 0;
+    this._secondX = 0; this._secondY = 0;
+    // Ring buffer for velocity (last 3 frames)
+    this._velBuf = [{ x: 0, y: 0, t: 0 }, { x: 0, y: 0, t: 0 }, { x: 0, y: 0, t: 0 }];
+    this._velIdx = 0;
+  }
+
+  GestureStateMachine.prototype.getState = function() { return this._state; };
+  GestureStateMachine.prototype.reset = function() {
+    this._state = 'IDLE';
+    this._pointerCount = 0;
+    if (this._holdTimer) { clearTimeout(this._holdTimer); this._holdTimer = null; }
+    if (this._doubleTapTimer) { clearTimeout(this._doubleTapTimer); this._doubleTapTimer = null; }
+  };
+
+  GestureStateMachine.prototype._pushVelocity = function(x, y, t) {
+    this._velBuf[this._velIdx] = { x: x, y: y, t: t };
+    this._velIdx = (this._velIdx + 1) % VELOCITY_BUFFER_SIZE;
+  };
+
+  GestureStateMachine.prototype._calcVelocity = function() {
+    var oldest = this._velBuf[(this._velIdx) % VELOCITY_BUFFER_SIZE];
+    var newest = this._velBuf[(this._velIdx + VELOCITY_BUFFER_SIZE - 1) % VELOCITY_BUFFER_SIZE];
+    var dt = newest.t - oldest.t;
+    if (dt <= 0) return { vx: 0, vy: 0 };
+    return { vx: (newest.x - oldest.x) / dt, vy: (newest.y - oldest.y) / dt };
+  };
+
+  GestureStateMachine.prototype.handlePointerDown = function(id, x, y, time) {
+    this._pointerCount++;
+    if (this._pointerCount >= 2) {
+      if (this._holdTimer) { clearTimeout(this._holdTimer); this._holdTimer = null; }
+      this._state = 'PINCH';
+      this._secondX = x; this._secondY = y;
+      this._pinchStartDist = _dist(this._startX, this._startY, x, y);
+      this._pinchCenterX = (this._startX + x) / 2;
+      this._pinchCenterY = (this._startY + y) / 2;
+      _evt.type = 'pinch_start'; _evt.centerX = this._pinchCenterX;
+      _evt.centerY = this._pinchCenterY; _evt.scale = 1;
+      return _evt;
+    }
+    this._startX = x; this._startY = y; this._startTime = time;
+    this._lastX = x; this._lastY = y; this._lastTime = time;
+    this._pushVelocity(x, y, time);
+
+    if (this._state === 'TAP_UP') {
+      // Check double-tap
+      if (this._doubleTapTimer) { clearTimeout(this._doubleTapTimer); this._doubleTapTimer = null; }
+      if (_dist(x, y, this._prevTapX, this._prevTapY) < DOUBLE_TAP_RADIUS) {
+        this._state = 'IDLE';
+        _evt.type = 'double_tap'; _evt.x = x; _evt.y = y;
+        return _evt;
+      }
+    }
+    this._state = 'PENDING_TAP';
+    // Start hold timer for drag detection
+    var self = this;
+    this._holdTimer = setTimeout(function() {
+      self._holdTimer = null;
+      if (self._state !== 'PENDING_TAP') return;
+      var getCurrentMode = self._options.getCurrentMode;
+      var raycastNode = self._options.raycastNode;
+      if (getCurrentMode && getCurrentMode() === 'CLOSE' && raycastNode) {
+        var nodeId = raycastNode(self._startX, self._startY);
+        if (nodeId != null) {
+          self._state = 'PENDING_DRAG';
+          _evt.type = 'drag_start'; _evt.x = self._startX; _evt.y = self._startY; _evt.nodeId = nodeId;
+          if (self._options.onGestureEvent) self._options.onGestureEvent(_evt);
+        }
+      }
+    }, DRAG_HOLD_TIME);
+    return _emitNone();
+  };
+
+  GestureStateMachine.prototype.handlePointerMove = function(id, x, y, time) {
+    if (this._state === 'PINCH') {
+      this._secondX = x; this._secondY = y;
+      var newDist = _dist(this._startX, this._startY, x, y);
+      var scale = this._pinchStartDist > 0 ? newDist / this._pinchStartDist : 1;
+      this._pinchCenterX = (this._startX + x) / 2;
+      this._pinchCenterY = (this._startY + y) / 2;
+      _evt.type = 'pinch_move'; _evt.scale = scale;
+      _evt.centerX = this._pinchCenterX; _evt.centerY = this._pinchCenterY;
+      return _evt;
+    }
+    if (this._state === 'PENDING_TAP') {
+      if (_dist(x, y, this._startX, this._startY) > PAN_THRESHOLD) {
+        if (this._holdTimer) { clearTimeout(this._holdTimer); this._holdTimer = null; }
+        this._state = 'PAN';
+        _evt.type = 'pan_start'; _evt.x = x; _evt.y = y;
+        return _evt;
+      }
+      return _emitNone();
+    }
+    if (this._state === 'PENDING_DRAG' || this._state === 'DRAG_NODE') {
+      this._state = 'DRAG_NODE';
+      _evt.type = 'drag_move'; _evt.x = x; _evt.y = y;
+      return _evt;
+    }
+    if (this._state === 'PAN') {
+      var dx = x - this._lastX, dy = y - this._lastY;
+      this._lastX = x; this._lastY = y; this._lastTime = time;
+      this._pushVelocity(x, y, time);
+      _evt.type = 'pan_move'; _evt.dx = dx; _evt.dy = dy;
+      return _evt;
+    }
+    return _emitNone();
+  };
+
+  GestureStateMachine.prototype.handlePointerUp = function(id, x, y, time) {
+    this._pointerCount = Math.max(0, this._pointerCount - 1);
+    if (this._state === 'PINCH') {
+      if (this._pointerCount > 0) { this._state = 'PAN'; this._lastX = x; this._lastY = y; this._lastTime = time; }
+      else { this._state = 'IDLE'; }
+      _evt.type = 'pinch_end'; _evt.scale = 1;
+      return _evt;
+    }
+    if (this._state === 'DRAG_NODE') {
+      this._state = 'IDLE';
+      _evt.type = 'drag_end'; _evt.x = x; _evt.y = y;
+      return _evt;
+    }
+    if (this._state === 'PENDING_DRAG') {
+      this._state = 'IDLE';
+      _evt.type = 'tap'; _evt.x = x; _evt.y = y;
+      return _evt;
+    }
+    if (this._state === 'PAN') {
+      var vel = this._calcVelocity();
+      this._state = 'IDLE';
+      _evt.type = 'pan_end'; _evt.velocityX = vel.vx; _evt.velocityY = vel.vy;
+      return _evt;
+    }
+    if (this._state === 'PENDING_TAP') {
+      if (this._holdTimer) { clearTimeout(this._holdTimer); this._holdTimer = null; }
+      var elapsed = time - this._startTime;
+      if (elapsed < TAP_MAX_DURATION && _dist(x, y, this._startX, this._startY) < PAN_THRESHOLD) {
+        this._prevTapX = x; this._prevTapY = y; this._prevTapTime = time;
+        this._state = 'TAP_UP';
+        var self = this;
+        this._doubleTapTimer = setTimeout(function() {
+          self._doubleTapTimer = null;
+          if (self._state === 'TAP_UP') {
+            self._state = 'IDLE';
+            _evt.type = 'tap'; _evt.x = x; _evt.y = y;
+            if (self._options.onGestureEvent) self._options.onGestureEvent(_evt);
+          }
+        }, DOUBLE_TAP_WINDOW);
+        return _emitNone();
+      }
+      this._state = 'IDLE';
+      return _emitNone();
+    }
+    this._state = 'IDLE';
+    return _emitNone();
+  };
+
+  global.GestureStateMachine = GestureStateMachine;
+})(typeof window !== 'undefined' ? window : this);