Fix return local time handling

Author: primum-mobile

CHANGELOG.md

@@ -2351,6 +2351,12 @@ Computation: The graphical ephemeris now builds its displayed day series over th
 
 GUI: The ephemeris longitude/declination view now uses one coherent x-axis mapping for plotted curves, month grid lines, hover dates, and snapped station markers. This removes the right-shifted hover date behavior, restores the missing month boundary line, and places the hover popup slightly closer to the snapped plot point.
 
+## 2026-04-09 01:26 (return timezone consistency)
+
+Computation: Return charts now convert computed revolution instants back to local civil time through the chart timezone when a real `tzid` is available, instead of reusing a fixed natal offset/DST assumption. Planetary return state now retains the zone fallback fields needed for reopen and stepper rebuilds, and revolution hit timestamps are rounded to the nearest second before the final refinement path.
+
+GUI: Solar, lunar, and planetary return tabs now show consistent local chart times in the wheel header and workspace labels, including after reopening a saved return session or stepping through return cycles. No other visible interface behavior changed.
+
 ## 2026-03-29 23:39 (synastry root-session swapping)
 
 Computation: No astrology midpoint or chart-construction formulas changed in this pass. Synastry still uses the same two source radix charts and composite conversion still uses the same pseudo-position builder, but synastry runtime state is now modeled as its own root workspace session whose active center chart can swap between the two radix inputs.

engine/supplementary_adapter.py

@@ -507,6 +507,12 @@ def normalize_retained_state(self, frame, current_chart=None, retained=None, pla
 			state['place_payload'] = place_payload
 		if 'plus' not in state:
 			state['plus'] = bool(getattr(getattr(current_chart, 'time', None), 'plus', True))
+		if 'zh' not in state:
+			state['zh'] = int(getattr(getattr(current_chart, 'time', None), 'zh', 0) or 0)
+		if 'zm' not in state:
+			state['zm'] = int(getattr(getattr(current_chart, 'time', None), 'zm', 0) or 0)
+		if 'daylight' not in state:
+			state['daylight'] = bool(getattr(getattr(current_chart, 'time', None), 'daylightsaving', False))
 		state['cycle_offset'] = int(state.get('cycle_offset', 0) or 0)
 		return state
 
@@ -568,18 +574,24 @@ def build(self, frame, driver_state, binding, current_chart=None, session=None):
 		raw_dt = tuple(int(v) for v in (t1, t2, t3, t4, t5, t6))
 		place = payload_to_place(retained.get('place_payload'), fallback=(getattr(current_chart, 'place', None) if current_chart is not None else getattr(base_chart, 'place', None)))
 		plus = bool(retained.get('plus', True))
+		zh = int(retained.get('zh', getattr(base_chart.time, 'zh', 0) or 0))
+		zm = int(retained.get('zm', getattr(base_chart.time, 'zm', 0) or 0))
+		daylight = bool(retained.get('daylight', getattr(base_chart.time, 'daylightsaving', False)))
 		if getattr(frame.options, 'ayanamsha', 0) != 0:
 			try:
 				t1, t2, t3, t4, t5, t6 = frame.calcPrecNutCorrectedRevolution(revs, pid, topo_place=place, seed=(t1, t2, t3, t4, t5, t6))
 			except Exception:
 				pass
 		time_obj = chart.Time(t1, t2, t3, t4, t5, t6, False, base_chart.time.cal, chart.Time.GREENWICH, plus, 0, 0, False, place, False)
 		revolution = chart.Chart(base_chart.name, base_chart.male, time_obj, place, chart.Chart.REVOLUTION, '', frame.options, False)
-		display_dt = frame._revolution_display_datetime(base_chart, t1, t2, t3, t4, t5, t6, plus=plus, zh=0, zm=0, daylight=False)
+		display_dt = frame._revolution_display_datetime(base_chart, t1, t2, t3, t4, t5, t6, plus=plus, zh=zh, zm=zm, daylight=daylight)
 		retained.update({
 			'planet_type': planet_type,
 			'place_payload': place_to_payload(place),
 			'plus': plus,
+			'zh': zh,
+			'zm': zm,
+			'daylight': daylight,
 			'cycle_offset': cycle_offset,
 			'raw_return_datetime': raw_dt,
 		})

morin.py

@@ -3760,7 +3760,13 @@ def _rebuild_workspace_lunar_return_child(self, current_chart, base_chart, targe
 		place = getattr(current_chart, 'place', None) or base_chart.place
 		time = chart.Time(t1, t2, t3, t4, t5, t6, False, base_chart.time.cal, chart.Time.GREENWICH, True, 0, 0, False, place, False)
 		revolution = chart.Chart(base_chart.name, base_chart.male, time, place, chart.Chart.LUNAR, '', self.options, False)
-		display_dt = self._revolution_display_datetime(base_chart, t1, t2, t3, t4, t5, t6, plus=True, zh=0, zm=0, daylight=False)
+		display_dt = self._revolution_display_datetime(
+			base_chart, t1, t2, t3, t4, t5, t6,
+			plus=True,
+			zh=getattr(base_chart.time, 'zh', 0),
+			zm=getattr(base_chart.time, 'zm', 0),
+			daylight=getattr(base_chart.time, 'daylightsaving', False),
+		)
 		return (revolution, display_dt)
 
 	def _supplementary_launch_context_for_session(self, feature_kind, chart_session_obj, fallback_chart=None):
@@ -6542,6 +6548,9 @@ def _workspace_open_planetary_return_from_document(self, document_id, planet_typ
 		result.binding.parent_source_datetime = self._datetime_to_display_tuple(ctx['source_datetime'])
 		place = supplementary_adapter.payload_to_place(result.binding.retained_state.get('place_payload'), fallback=base_chart.place)
 		plus = bool(result.binding.retained_state.get('plus', True))
+		zh = int(result.binding.retained_state.get('zh', getattr(base_chart.time, 'zh', 0) or 0))
+		zm = int(result.binding.retained_state.get('zm', getattr(base_chart.time, 'zm', 0) or 0))
+		daylight = bool(result.binding.retained_state.get('daylight', getattr(base_chart.time, 'daylightsaving', False)))
 		raw_return_dt = result.binding.retained_state.get('raw_return_datetime')
 		cycle_offset = int(result.binding.retained_state.get('cycle_offset', 0) or 0)
 		label = self._workspace_timed_label(mtexts.revtypeList[planet_type], result.display_datetime[0], result.display_datetime[1], result.display_datetime[2], result.display_datetime[3], result.display_datetime[4], result.display_datetime[5])
@@ -6551,7 +6560,10 @@ def _workspace_open_planetary_return_from_document(self, document_id, planet_typ
 				result.chart,
 				result.display_datetime,
 				result.binding,
-				after_change=lambda active_cs: self._install_workspace_planetary_revolution_stepper(active_cs, base_chart, planet_type, place, plus, raw_return_dt, cycle_offset=cycle_offset),
+				after_change=lambda active_cs: self._install_workspace_planetary_revolution_stepper(
+					active_cs, base_chart, planet_type, place, plus, raw_return_dt,
+					zh=zh, zm=zm, daylight=daylight, cycle_offset=cycle_offset,
+				),
 			)
 			existing_session['launcher_kind'] = 'planetary_return'
 			existing_session['planetary_return_type'] = int(planet_type)
@@ -6564,7 +6576,10 @@ def _workspace_open_planetary_return_from_document(self, document_id, planet_typ
 			radix=base_chart,
 			parent_document_id_override=ctx.get('parent_document_id'),
 			indent_level_override=(selected_indent + 1),
-			after_open=lambda active_cs: self._install_workspace_planetary_revolution_stepper(active_cs, base_chart, planet_type, place, plus, raw_return_dt, cycle_offset=cycle_offset),
+			after_open=lambda active_cs: self._install_workspace_planetary_revolution_stepper(
+				active_cs, base_chart, planet_type, place, plus, raw_return_dt,
+				zh=zh, zm=zm, daylight=daylight, cycle_offset=cycle_offset,
+			),
 		)
 		if doc is not None:
 			session = self._find_workspace_session(doc.document_id)
@@ -7305,6 +7320,31 @@ def _zone_adjusted_datetime(self, y, m, d, h, mi, s, plus, zh, zm, daylight=Fals
 			return (int(y), int(m), int(d), int(h), int(mi), int(s))
 
 	def _revolution_display_datetime(self, radix, y, m, d, h, mi, s, plus=None, zh=None, zm=None, daylight=None):
+		if radix is not None:
+			tzid = getattr(getattr(radix, 'time', None), 'tzid', '') or ''
+			zoneinfo_cls = getattr(geonames, 'ZoneInfo', None)
+			if not tzid and getattr(radix, 'place', None) is not None:
+				try:
+					tzid = geonames.Geonames.get_timezone_name(radix.place.lon, radix.place.lat) or ''
+				except Exception:
+					tzid = ''
+			if tzid and zoneinfo_cls is not None:
+				try:
+					utc_dt = datetime.datetime(
+						int(y), int(m), int(d), int(h), int(mi), int(s),
+						tzinfo=datetime.timezone.utc,
+					)
+					local_dt = utc_dt.astimezone(zoneinfo_cls(tzid))
+					return (
+						local_dt.year,
+						local_dt.month,
+						local_dt.day,
+						local_dt.hour,
+						local_dt.minute,
+						local_dt.second,
+					)
+				except Exception:
+					pass
 		if plus is None:
 			plus = getattr(radix.time, 'plus', True)
 		if zh is None:
@@ -7936,7 +7976,7 @@ def _reset_lr_step_state():
 		else:
 			self._rev_stepper.Show(False)
 
-	def _install_workspace_planetary_revolution_stepper(self, active_cs, radix_chart, planet_type, place, plus, raw_return_dt, cycle_offset=0):
+	def _install_workspace_planetary_revolution_stepper(self, active_cs, radix_chart, planet_type, place, plus, raw_return_dt, zh=0, zm=0, daylight=False, cycle_offset=0):
 		if active_cs is None or radix_chart is None or raw_return_dt is None:
 			return
 		pid = revolutions.Revolutions.planetary_pid(planet_type)
@@ -7949,6 +7989,9 @@ def _install_workspace_planetary_revolution_stepper(self, active_cs, radix_chart
 		self._rev_ctx = {
 			'place': place,
 			'plus': plus,
+			'zh': zh,
+			'zm': zm,
+			'daylight': daylight,
 			'revtype': chart.Chart.REVOLUTION,
 			'planet_type': int(planet_type),
 			'cycle_offset': int(cycle_offset),
@@ -7971,7 +8014,10 @@ def _apply_planet_rev(revs2):
 			self._planet_rev_dt = raw_dt
 			display_dt = self._revolution_display_datetime(
 				radix_chart, int(ry), int(rm), int(rd), int(rhh), int(rmi), int(rss),
-				plus=self._rev_ctx['plus'], zh=0, zm=0, daylight=False,
+				plus=self._rev_ctx['plus'],
+				zh=self._rev_ctx.get('zh', 0),
+				zm=self._rev_ctx.get('zm', 0),
+				daylight=self._rev_ctx.get('daylight', False),
 			)
 			active_cs.change_chart(chart2, display_datetime=display_dt, change_reason='step')
 
@@ -8158,7 +8204,13 @@ def _open_quick_planet_revolution(self, planet_type):
 
 		time = chart.Time(t1, t2, t3, t4, t5, t6, False, radix.time.cal, chart.Time.GREENWICH, plus, 0, 0, False, place, False)
 		revolution = chart.Chart(radix.name, radix.male, time, place, chart.Chart.REVOLUTION, '', self.options, False)
-		display_dt = self._revolution_display_datetime(radix, t1, t2, t3, t4, t5, t6, plus=plus, zh=0, zm=0, daylight=False)
+		display_dt = self._revolution_display_datetime(
+			radix, t1, t2, t3, t4, t5, t6,
+			plus=plus,
+			zh=getattr(radix.time, 'zh', 0),
+			zm=getattr(radix.time, 'zm', 0),
+			daylight=getattr(radix.time, 'daylightsaving', False),
+		)
 		label = self._workspace_timed_label(mtexts.revtypeList[planet_type], display_dt[0], display_dt[1], display_dt[2], display_dt[3], display_dt[4], display_dt[5])
 		doc = self._open_workspace_session(
 			revolution, session_label=label,
@@ -8168,7 +8220,14 @@ def _open_quick_planet_revolution(self, planet_type):
 		if doc is None:
 			return
 
-		self._rev_ctx = {'place': place, 'plus': plus, 'revtype': chart.Chart.REVOLUTION}
+		self._rev_ctx = {
+			'place': place,
+			'plus': plus,
+			'zh': getattr(radix.time, 'zh', 0),
+			'zm': getattr(radix.time, 'zm', 0),
+			'daylight': getattr(radix.time, 'daylightsaving', False),
+			'revtype': chart.Chart.REVOLUTION,
+		}
 		self._planet_rev_dt = datetime.datetime(int(revs.t[0]), int(revs.t[1]), int(revs.t[2]), int(revs.t[3]), int(revs.t[4]), int(revs.t[5]))
 		try:
 			if hasattr(self, '_rev_stepper') and self._rev_stepper:
@@ -8197,7 +8256,10 @@ def _apply_planet_rev(revs2):
 			if active_cs is not None:
 				display_dt = self._revolution_display_datetime(
 					radix, int(ry), int(rm), int(rd), int(rhh), int(rmi), int(rss),
-					plus=self._rev_ctx['plus'], zh=0, zm=0, daylight=False,
+					plus=self._rev_ctx['plus'],
+					zh=self._rev_ctx.get('zh', 0),
+					zm=self._rev_ctx.get('zm', 0),
+					daylight=self._rev_ctx.get('daylight', False),
 				)
 				active_cs.change_chart(chart2, display_datetime=display_dt, change_reason='step')
 
@@ -11372,14 +11434,27 @@ def onRevolutions(self, event):
 						time = chart.Time(t1, t2, t3, t4, t5, t6, False, radix.time.cal, chart.Time.GREENWICH, plus, 0, 0, False, place, False)
 
 						revolution = chart.Chart(radix.name, radix.male, time, place, revtype, '', self.options, False)
-						display_dt = self._revolution_display_datetime(radix, t1, t2, t3, t4, t5, t6, plus=plus, zh=0, zm=0, daylight=False)
+						display_dt = self._revolution_display_datetime(
+							radix, t1, t2, t3, t4, t5, t6,
+							plus=plus,
+							zh=getattr(radix.time, 'zh', 0),
+							zm=getattr(radix.time, 'zm', 0),
+							daylight=getattr(radix.time, 'daylightsaving', False),
+						)
 						rev_label = self._workspace_timed_label(mtexts.typeList[revtype], display_dt[0], display_dt[1], display_dt[2], display_dt[3], display_dt[4], display_dt[5])
 						self._open_workspace_session(
 							revolution, session_label=rev_label,
 							radix=radix, view_mode=chart_session.ChartSession.CHART,
 							display_datetime=display_dt,
 						)
-						self._rev_ctx   = {'place': place, 'plus': plus, 'revtype': revtype}
+						self._rev_ctx   = {
+							'place': place,
+							'plus': plus,
+							'zh': getattr(radix.time, 'zh', 0),
+							'zm': getattr(radix.time, 'zm', 0),
+							'daylight': getattr(radix.time, 'daylightsaving', False),
+							'revtype': revtype,
+						}
 
 						# 이전에 떠 있던 스텝퍼가 있으면 닫기(다른 리턴일 수도 있으니 먼저 정리)
 						try:
@@ -11569,7 +11644,10 @@ def _apply_planet_rev(revs2):
 								if active_cs2 is not None:
 									display_dt = self._revolution_display_datetime(
 										radix, int(ry), int(rm), int(rd), int(rhh), int(rmi), int(rss),
-										plus=self._rev_ctx['plus'], zh=0, zm=0, daylight=False,
+										plus=self._rev_ctx['plus'],
+										zh=self._rev_ctx.get('zh', 0),
+										zm=self._rev_ctx.get('zm', 0),
+										daylight=self._rev_ctx.get('daylight', False),
 									)
 									active_cs2.change_chart(
 										chart2,

revolutions.py

@@ -44,6 +44,24 @@ def __init__(self):
     def _planet_params(self, typ):
         return Revolutions.PLANETARY_SPECS.get(typ, (None, 0))
 
+    def _rounded_transit_values(self, year, month, day, time_float):
+        total_seconds = int(round(float(time_float) * 3600.0))
+        y = int(year)
+        m = int(month)
+        d = int(day)
+
+        while total_seconds >= 86400:
+            total_seconds -= 86400
+            y, m, d = util.incrDay(y, m, d)
+        while total_seconds < 0:
+            total_seconds += 86400
+            y, m, d = util.decrDay(y, m, d)
+
+        hour = total_seconds // 3600
+        minute = (total_seconds % 3600) // 60
+        second = total_seconds % 60
+        return (y, m, d, int(hour), int(minute), int(second))
+
     @classmethod
     def is_planetary_type(cls, typ):
         return typ in cls.PLANETARY_SPECS
@@ -56,8 +74,8 @@ def planetary_pid(cls, typ):
         return spec[0]
 
     def _candidate_datetime(self, year, month, tr):
-        hour, minute, second = util.decToDeg(tr.time)
-        return datetime.datetime(int(year), int(month), int(tr.day), int(hour), int(minute), int(second))
+        values = self._rounded_transit_values(year, month, tr.day, tr.time)
+        return datetime.datetime(*values)
 
     def _set_candidate(self, year, month, trans, index):
         self.createRevolution(int(year), int(month), trans, int(index))
@@ -118,11 +136,7 @@ def _lunar_month_hits(self, year, month, chrt):
         trans.month(int(year), int(month), chrt, astrology.SE_MOON)
         hits = []
         for tr in trans.transits:
-            hour, minute, second = util.decToDeg(tr.time)
-            values = (
-                int(year), int(month), int(tr.day),
-                int(hour), int(minute), int(second),
-            )
+            values = self._rounded_transit_values(year, month, tr.day, tr.time)
             hits.append((self._dt_from_t(values), values))
         hits = tuple(hits)
 
@@ -150,11 +164,7 @@ def _planetary_month_hits(self, typ, year, month, chrt):
         trans.month(int(year), int(month), chrt, planet)
         hits = []
         for tr in trans.transits:
-            hour, minute, second = util.decToDeg(tr.time)
-            values = (
-                int(year), int(month), int(tr.day),
-                int(hour), int(minute), int(second),
-            )
+            values = self._rounded_transit_values(year, month, tr.day, tr.time)
             hits.append((self._dt_from_t(values), values))
         hits = tuple(hits)
 
@@ -314,10 +324,10 @@ def compute(self, typ, by, bm, bd, chrt, target_year=None):
 
 
     def createRevolution(self, year, month, trans, num = 0):
-        self.t[0] = year
-        self.t[1] = month
-        self.t[2] = trans.transits[num].day
-        h, m, s = util.decToDeg(trans.transits[num].time)
-        self.t[3] = h
-        self.t[4] = m
-        self.t[5] = s
+        values = self._rounded_transit_values(year, month, trans.transits[num].day, trans.transits[num].time)
+        self.t[0] = values[0]
+        self.t[1] = values[1]
+        self.t[2] = values[2]
+        self.t[3] = values[3]
+        self.t[4] = values[4]
+        self.t[5] = values[5]