[advtrains] přechod na Advtrains 2.5.0 (první pokus)

- [ch_core/lib] drobná oprava
- [advtrains_attachment_offset_patch] použití initial_properties

23 files changed, 3103 insertions, 1271 deletions

diff --git a/advtrains_interlocking/README.md b/advtrains_interlocking/README.md
new file mode 100644
index 0000000..d4a2699
--- /dev/null
+++ b/advtrains_interlocking/README.md
@@ -0,0 +1,85 @@
+# Interlocking for Advtrains
+
+The `advtrains_interlocking` mod provides various interlocking and signaling features for Advtrains.
+
+## Signal aspect tables
+
+Signal aspects are represented using tables with the following (optional) fields:
+
+* `main`: The main signal aspect. It provides information on the permitted speed after passing the signal.
+* `dst`: The distant signal aspect. It provides information on the permitted speed after passing the next signal.
+* `shunt`: Whether the train may proceed in shunt mode and, if the main aspect is danger, proceed in shunt mode.
+* `proceed_as_main`: Whether the train should exit shunt mode when proceeding.
+* `group`: The name of the signal group.
+* `name`: The name of the signal aspect.
+
+The `main` and `dst` fields may be:
+
+* An positive number indicating the permitted speed,
+* The number 0, indicating that the train should expect to stop at the current signal (or, for the `dst` field, the next signal),
+* The number -1, indicating that the train can proceed (or, for the `dst` field, expect to proceed) at maximum speed,
+* The constant `false`, indicating no change to the speed restriction, or
+* The constant `nil`, indicating that the default value for the name aspect (if present) is used. If no valid signal aspect is named, or the signal aspect does not provide a default value, the value is assumed to be `false`.
+
+### Node definitions
+
+Signals should belong the following node groups:
+
+* `advtrains_signal`: `1` for static signals, `2` for signals with variable aspects.
+* `save_in_at_nodedb`: This should be set to `1` to make sure that Advtrains always has access to the signal.
+* `not_blocking_trains`: Setting this to `1` prevents trains from colliding with the signal. Setting this is not necessary, but recommended.
+
+The node definition should contain an `advtrains` field.
+
+The `advtrains` field of the node definition should contain a `supported_aspects` table for signals with variable aspects.
+
+The `supported_aspects` table should contain the following fields:
+
+* `main`: A list of values supported for the main aspect.
+* `dst`: A list of values supported for the distant aspect.
+* `shunt`: The value for the `shunt` field of the signal aspect or `nil` if the value is variable.
+* `proceed_as_main`: The value for the `proceed_as_main` field of the signal aspect.
+* `group`: The name of the signal group.
+* `name`: A list of supported (named) aspects.
+* `dst_shift`: The phase shift for distant/repeater signals. This field should not be set for main signals.
+
+The `advtrains` field of the node definition should contain a `get_aspect` function. This function is given the position of the signal and the node at the position. It should return the signal aspect table or, in the case of type 2 signals, the name of the signal aspect.
+
+For signals with variable aspects, a corresponding `set_aspect` function should also be defined. This function is given the position of the signal, the node at the position, and the new aspect. The new aspect is not guaranteed to be supported by the signal itself.
+
+Signals should also have the following callbacks set:
+
+* `on_rightclick` should be set to `advtrains.interlocking.signal_rc_handler`
+* `can_dig` should be set to `advtrains.interlocking.signal_can_dig`
+* `after_dig_node` should be set to `advtrains.interlocking.signal_after_dig`
+
+Alternatively, custom callbacks should call the respective functions.
+
+## Signal groups
+
+Signals may belong to signal groups are registered using `advtrains.interlocking.aspect.register_group`.
+
+Signal group definitions include the following fields:
+
+* `name`: The internal name of the signal group. It is recommended to use the mod name as a prefix to avoid name collisions.
+* `label`: The description of the signal group.
+* `aspects`: A table of signal aspects. Entries with string indices define the signal aspect with the name. Entries with numeric indices (starting from 1, counting upward) contain a list of corresponding aspect names (the first entry is preferred) and are mainly used for routing, where larger indices indicate that the signal with the aspect is closer to the signal with the "danger" (or similar) aspect.
+
+Each aspect in the signal group definition table should contain the following fields:
+
+* `label`: The description of the signal aspect.
+* `main`, `shunt`, `proceed_as_main`: The default values for the aspect. Note that the `dst` field has no default value as it is automatically adjusted.
+
+## Notes
+
+It is allowed to provide other methods of setting the signal aspect. However:
+
+* These changes are ignored by the routesetting system.
+* Please call `advtrains.interlocking.signal_readjust_aspect` after the signal aspect has changed.
+
+## Examples
+An example of speed signals can be found in `advtrains_signals_ks`, which provides a subset of German signals.
+
+An example of route signals can be found in `advtrains_signals_japan`, which provides a subset of Japanese signals.
+
+The mods mentioned above are also used for demonstation purposes and can also be used for testing.
diff --git a/advtrains_interlocking/approach.lua b/advtrains_interlocking/approach.lua
index eecf09a..eaf0248 100644
--- a/advtrains_interlocking/approach.lua
+++ b/advtrains_interlocking/approach.lua
@@ -64,10 +64,7 @@ advtrains.tnc_register_on_approach(function(pos, id, train, index, has_entered,
 	-- resetting the path does not matter to the set route and ARS doesn't need to be called again.
 	if spos and ars_enabled then
 		--atdebug(id,"IL Spos (ARS)",spos,asp)
-		local sigd = il.db.get_sigd_for_signal(spos)
-		if sigd then
-			il.ars_check(sigd, train)
-		end
+		il.ars_check(spos, train)
 	end
 	--atdebug("trav: ",pos, cn, asp, spos, "travsht=", lzb.travsht)
 	local lspd
diff --git a/advtrains_interlocking/ars.lua b/advtrains_interlocking/ars.lua
index 4f50df9..eb10497 100644
--- a/advtrains_interlocking/ars.lua
+++ b/advtrains_interlocking/ars.lua
@@ -52,7 +52,7 @@ function il.ars_to_text(arstab)
 end
 
 function il.text_to_ars(t)
-	if t=="" then
+	if not string.match(t, "%S+") then
 		return nil
 	elseif t=="*" then
 		return {default=true}
@@ -129,29 +129,49 @@ function il.ars_check_rule_match(ars, train)
 		return nil
 end
 
-function advtrains.interlocking.ars_check(sigd, train)
-	local tcbs = il.db.get_tcbs(sigd)
-	if not tcbs or not tcbs.routes then return end
-	
-	if tcbs.ars_disabled or tcbs.ars_ignore_next then
-		-- No-ARS mode of signal.
-		-- ignore...
-		-- Note: ars_ignore_next is set by signalling formspec when route is cancelled
-		tcbs.ars_ignore_next = nil
-		return
-	end
-	
-	if tcbs.routeset then
-		-- ARS is not in effect when a route is already set
-		-- just "punch" routesetting, just in case callback got lost.
-		minetest.after(0, il.route.update_route, sigd, tcbs, nil, nil)
-		return
+function advtrains.interlocking.ars_check(signalpos, train, trig_from_dst)
+	-- check for distant signal
+	-- this whole check must be delayed until after the route setting has taken place, 
+	-- because before that the distant signal is yet unknown
+	if not trig_from_dst then
+		minetest.after(0.5, function()
+			-- does signal have dst?
+			local _, remote = il.signal.get_aspect(signalpos)
+			if remote then
+				advtrains.interlocking.ars_check(remote, train, true)
+			end
+		end)
 	end
-	
-	local rteid = find_rtematch(tcbs.routes, train)
-	if rteid then
-		--delay routesetting, it should not occur inside train step
-		-- using after here is OK because that gets called on every path recalculation
-		minetest.after(0, il.route.update_route, sigd, tcbs, rteid, nil)
+
+	local sigd = il.db.get_sigd_for_signal(signalpos)
+	local tcbs = sigd and il.db.get_tcbs(sigd)
+	-- trigger ARS on this signal
+	if tcbs and tcbs.routes then
+		
+		if tcbs.ars_disabled or tcbs.ars_ignore_next then
+			-- No-ARS mode of signal.
+			-- ignore...
+			-- Note: ars_ignore_next is set by signalling formspec when route is cancelled
+			tcbs.ars_ignore_next = nil
+			return
+		end
+		if trig_from_dst and tcbs.no_dst_ars_trig then
+			-- signal not to be triggered from distant
+			return
+		end
+		
+		if tcbs.routeset then
+			-- ARS is not in effect when a route is already set
+			-- just "punch" routesetting, just in case callback got lost.
+			minetest.after(0, il.route.update_route, sigd, tcbs, nil, nil)
+			return
+		end
+		
+		local rteid = find_rtematch(tcbs.routes, train)
+		if rteid then
+			--delay routesetting, it should not occur inside train step
+			-- using after here is OK because that gets called on every path recalculation
+			minetest.after(0, il.route.update_route, sigd, tcbs, rteid, nil)
+		end
 	end
 end
diff --git a/advtrains_interlocking/autonaming.lua b/advtrains_interlocking/autonaming.lua
new file mode 100644
index 0000000..f88ccbd
--- /dev/null
+++ b/advtrains_interlocking/autonaming.lua
@@ -0,0 +1,69 @@
+-- autonaming.lua
+-- Automatically set names of signals (and maybe track sections) based on numbering
+
+
+local function find_highest_count(prefix)
+	local cnt = 0
+	local pattern = "^"..prefix.."(%d+)$"
+	local alltcb = advtrains.interlocking.db.get_all_tcb()
+	for _,tcb in pairs(alltcb) do
+		for _,tcbs in pairs(tcb) do
+			if tcbs.signal_name then
+				local mnum = string.match(tcbs.signal_name, pattern)
+				if mnum then
+					local n = tonumber(mnum)
+					if n and n > cnt then
+						cnt = n
+					end
+				end
+			end
+		end
+	end
+	return cnt
+end
+
+-- { pname = { prefix = "FOO", count = 7 } }
+local player_prefix_info = {}
+
+function advtrains.interlocking.set_autoname_prefix(pname, prefix)
+	if prefix and #prefix>0 then
+		-- check that it is valid
+		if not string.match(prefix,"[A-Za-z_]+") then
+			return false, "Illegal prefix, only letters and _ allowed"
+		end
+		-- scan database for this prefix to find out the highest count
+		local count = find_highest_count(prefix)
+		player_prefix_info[pname] = { prefix = prefix, count = count}
+		return true, "Prefix set, next signal name will be: ".. advtrains.interlocking.get_next_autoname(pname, true)
+	else
+		player_prefix_info[pname] = nil
+		return true, "Prefix unset, signals are not auto-named for you!"
+	end
+end
+
+function advtrains.interlocking.get_next_autoname(pname, no_increment)
+	local pi = player_prefix_info[pname]
+	if pi then
+		local name = pi.prefix..(pi.count+1)
+		if not no_increment then pi.count = pi.count+1 end
+		return name
+	else
+		return nil
+	end
+end
+
+function advtrains.interlocking.add_autoname_to_tcbs(tcbs, pname)
+	if not tcbs or not pname then return end
+	if tcbs.signal_name then return end -- name already set
+	
+	tcbs.signal_name = advtrains.interlocking.get_next_autoname(pname)
+end
+
+minetest.register_chatcommand("at_nameprefix",
+	{
+		params = "<prefix>",
+		description = "Sets the current prefix for automatically naming interlocking components. Example: '/at_nameprefix TEST' - signals will be named TEST1, TEST2 and so on",
+		privs = {interlocking = true},
+		func = advtrains.interlocking.set_autoname_prefix,
+})
+
diff --git a/advtrains_interlocking/database.lua b/advtrains_interlocking/database.lua
index a362296..844d350 100644
--- a/advtrains_interlocking/database.lua
+++ b/advtrains_interlocking/database.lua
@@ -2,71 +2,19 @@
 -- saving the location of TCB's, their neighbors and their state
 --[[
 
-== THIS COMMENT IS PARTIALLY INCORRECT AND OUTDATED! ==
-
-The interlocking system is based on track circuits.
-Track circuit breaks must be manually set by the user. Signals must be assigned to track circuit breaks and to a direction(connid).
-To simplify the whole system, there is no overlap.
-== Trains ==
-Trains always occupy certain track circuits. These are shown red in the signalbox view (TRAIN occupation entry).
-== Database storage ==
-The things that are actually saved are the Track Circuit Breaks. Each TCB holds a list of the TCBs that are adjacent in each direction.
-TC occupation/state is then saved inside each (TCB,Direction) and held in sync across all TCBs adjacent to this one. If something should not be in sync,
-all entries are merged to perform the most restrictive setup.
-== Traverser function ==
-To determine and update the list of neighboring TCBs, we need a traverser function.
-It will start at one TCB in a specified direction (connid) and use get_adjacent_rail to crawl along the track. When encountering a turnout or a crossing,
-it needs to branch(call itself recursively) to find all required TCBs. Those found TCBs are then saved in a list as tuples (TCB,Dir)
-In the last step, they exchange their neighbors.
-== TC states ==
-A track circuit does not have a state as such, but has more or less a list of "reservations"
-type can be one of these:
-TRAIN See Trains obove
-ROUTE Route set from a signal, but no train has yet passed that signal.
-Not implemented (see note by reversible): OWNED - former ROUTE segments that a train has begun passing (train_id assigned)
-		  - Space behind a train up to the next signal, when a TC is set as REVERSIBLE
-Certain TCs can be marked as "allow call-on".
-== Route setting: ==
-Routes are set from a signal (the entry signal) to another signal facing the same direction (the exit signal)
-Remember that signals are assigned to a TCB and a connid.
-Whenever this is done, the following track circuits are set "reserved" by the train by saving the entry signal's ID:
-- all TCs on the direct way of the route - set as ROUTE
-Route setting fails whenever any TC that we want to set ROUTE to is already set ROUTE or TRAIN from another signal (except call-on, see below)
-Apart from this, we need to set turnouts
-- Turnouts on the track are set held as ROUTE
-- Turnouts that purpose as flank protection are set held as FLANK (NOTE: left as an idea for later, because it's not clear how to do this properly without an engineer)
-Note: In SimSig, it is possible to set a route into an still occupied section on the victoria line sim. (at the depot exit at seven sisters), although
-	there are still segments set ahead of the first train passing, remaining from another route.
-	Because our system will be able to remember "requested routes" and set them automatically once ready, this is not necessary here.
-== Call-On/Multiple Trains ==
-It will be necessary to join and split trains using call-on routes. A call-on route may be set when:
-- there are no ROUTE reservations
-- there are TRAIN reservations only inside TCs that have "allow call-on" set
-== TC Properties ==
-Note: Reversible property will not be implemented, assuming everything as non-rev.
-This is sufficient to cover all use cases, and is done this way in reality.
-	REVERSIBLE - Whether trains are allowed to reverse while on track circuit
-	This property is supposed to be set for station tracks, where there is a signal at each end, and for sidings.
-	It should in no case be set for TCs covering turnouts, or for main running lines.
-	When a TC is not set as reversible, the OWNED status is cleared from the TC right after the train left it,
-	to allow other trains to pass it.
-	If it is set reversible, interlocking will keep the OWNED state behind the train up to the next signal, clearing it
-	as soon as the train passes another signal or enters a non-reversible section.
-CALL_ON_ALLOWED - Whether this TC being blocked (TRAIN or ROUTE) does not prevent shunt routes being set through this TC
-== More notes ==
-- It may not be possible to switch turnouts when their TC has any state entry
-
 == Route releasing (TORR) ==
 A train passing through a route happens as follows:
 Route set from entry to exit signal
-Train passes entry signal and enters first TC past the signal
--> Route from signal cleared (TCs remain locked)
--> ROUTE status of first TC past signal cleared
+Train passes entry signal and enters first TS past the signal
+-> Route from signal cleared (TSs remain locked)
+-> 'route' status of first TS past signal cleared
+-> 'route_post' (holding the turnout locks) remains set
 Train continues along the route.
-Whenever train leaves a TC
+Whenever train leaves a TS
 -> Clearing any routes set from this TC outward recursively - see "Reversing problem"
-Whenever train enters a TC
--> Clear route status from the just entered TC
+-> Free turnout locks and clear 'route_post'
+Whenever train enters a TS
+-> Clear route status from the just entered TC (but not route_post)
 Note that this prohibits by design that the train clears the route ahead of it.
 == Reversing Problem ==
 Encountered at the Royston simulation in SimSig. It is solved there by imposing a time limit on the set route. Call-on routes can somehow be set anyway.
@@ -89,6 +37,22 @@ Another case of this:
 The / here is a non-interlocked turnout (to a non-frequently used siding). For some reason, there is no exit node there,
 so the route is set to the signal at the right end. The train is taking the exit to the siding and frees the TC, without ever
 having touched the right TC.
+
+
+== Terminology / Variable Names ==
+
+"tcb" : A TCB table (as in track_circuit_breaks)
+"tcbs" : One side of a tcb (that is tcb == {[1] = tcbs, [2] = tcbs})
+"sigd" : A table of format {p=<position>, s=<side aka connid>} by which a "tcbs" is uniqely identified.
+
+== Section Autorepair & Turnout Cache ==
+
+As fundamental part of reworked route programming mechanism, Track Section objects become weak now. They are created and destroyed on demand.
+ildb.repair_tcb automatically checks all nearby sections for issues and repairs them automatically.
+
+Also the database now holds a cache of the turnouts in the section and their position for all possible driving paths.
+Every time a repair operation takes place, and on every track edit operation, the affected sections need to have their cache updated.
+
 ]]--
 
 local TRAVERSER_LIMIT = 1000
@@ -111,7 +75,45 @@ advtrains.interlocking.npr_rails = {}
 function ildb.load(data)
 	if not data then return end
 	if data.tcbs then
-		track_circuit_breaks = data.tcbs
+		if data.tcbpts_conversion_applied then
+			track_circuit_breaks = data.tcbs
+		else
+			-- Convert legacy pos_to_string tcbs to new advtrains.encode_pos position strings
+			for pts, tcb in pairs(data.tcbs) do
+				local pos = minetest.string_to_pos(pts)
+				if pos then
+					-- that was a pos_to_string
+					local epos = advtrains.encode_pos(pos)
+					atdebug("ILDB converting TCB position format",pts,"->",epos)
+					track_circuit_breaks[epos] = tcb
+				else
+					-- keep entry, it is already new
+					track_circuit_breaks[pts] = tcb
+				end
+				-- convert the routes.[].locks table keys
+				for t_side,tcbs in pairs(tcb) do
+					if tcbs.routes then
+						for t_rnum,route in pairs(tcbs.routes) do
+							for t_rsnm,rseg in ipairs(route) do
+								local locks_n = {}
+								for lpts,state in pairs(rseg.locks) do
+									local lpos = minetest.string_to_pos(lpts)
+									if lpos then
+										local epos = advtrains.encode_pos(lpos)
+										atdebug("ILDB converting tcb",pts,"side",t_side,"route",t_rnum,"lock position format",lpts,"->",epos)
+										locks_n[epos] = state
+									else
+										-- already correct format
+										locks_n[lpts] = state
+									end
+								end
+								rseg.locks = locks_n
+							end
+						end
+					end
+				end
+			end
+		end
 	end
 	if data.ts then
 		track_sections = data.ts
@@ -120,7 +122,23 @@ function ildb.load(data)
 		signal_assignments = data.signalass
 	end
 	if data.rs_locks then
-		advtrains.interlocking.route.rte_locks = data.rs_locks
+		if data.tcbpts_conversion_applied then
+			advtrains.interlocking.route.rte_locks = data.rs_locks
+		else
+			advtrains.interlocking.route.rte_locks = {}
+			for pts, lta in pairs(data.rs_locks) do
+				local pos = minetest.string_to_pos(pts)
+				if pos then
+					-- that was a pos_to_string
+					local epos = advtrains.encode_pos(pos)
+					atdebug("ILDB converting Route Lock position format",pts,"->",epos)
+					advtrains.interlocking.route.rte_locks[epos] = lta
+				else
+					-- keep entry, it is already new
+					advtrains.interlocking.route.rte_locks[pts] = lta
+				end
+			end
+		end
 	end
 	if data.rs_callbacks then
 		advtrains.interlocking.route.rte_callbacks = data.rs_callbacks
@@ -132,6 +150,9 @@ function ildb.load(data)
 		advtrains.interlocking.npr_rails = data.npr_rails
 	end
 	
+	-- let signal_api load data
+	advtrains.interlocking.signal.load(data)
+	
 	--COMPATIBILITY to Signal aspect format
 	-- TODO remove in time...
 	for pts,tcb in pairs(track_circuit_breaks) do
@@ -165,7 +186,7 @@ function ildb.load(data)
 end
 
 function ildb.save()
-	return {
+	local data = {
 		tcbs = track_circuit_breaks,
 		ts=track_sections,
 		signalass = signal_assignments,
@@ -173,7 +194,10 @@ function ildb.save()
 		rs_callbacks = advtrains.interlocking.route.rte_callbacks,
 		influence_points = influence_points,
 		npr_rails = advtrains.interlocking.npr_rails,
+		tcbpts_conversion_applied = true, -- remark that legacy pos conversion has taken place
 	}
+	advtrains.interlocking.signal.save(data)
+	return data
 end
 
 --
@@ -183,6 +207,9 @@ TCB data structure
 -- This is the "A" side of the TCB
 [1] = { -- Variant: with adjacent TCs.
 	ts_id = <id> -- ID of the assigned track section
+	xlink = <other sigd> -- If two sections of track are not physically joined but must function as one TS (e.g. knights move crossing), a bidirectional link can be added with exactly one other TCB.
+	-- TS search will behave as if these two TCBs were physically connected.
+	
 	signal = <pos> -- optional: when set, routes can be set from this tcb/direction and signal
 	-- aspect will be set accordingly.
 	routeset = <index in routes> -- Route set from this signal. This is the entry that is cleared once
@@ -195,20 +222,63 @@ TCB data structure
 	signal_name = <string> -- The human-readable name of the signal, only for documenting purposes
 	routes = { <route definition> } -- a collection of routes from this signal
 	route_auto = <boolean> -- When set, we will automatically re-set the route (designated by routeset)
+	
+	auto_block_signal_mode = <boolean> -- Simplified mode for simple block signals:
+	-- Signal has only one route which is constantly re-set (route_auto is implied)
+	-- Supposed to be used when only a single track section is ahead and it directly ends at the next signal
+	-- UI only offers to enable or disable the signal
+	-- ARS is implicitly disabled on the signal
 },
 -- This is the "B" side of the TCB
 [2] = { -- Variant: end of track-circuited area (initial state of TC)
 	ts_id = nil, -- this is the indication for end_of_interlocking
-	section_free = <boolean>, --this can be set by an exit node via mesecons or atlatc, 
-	-- or from the tc formspec.
 }
 }
 
+Route definition
+routes = {
+	[i] = {
+		-- one table for each track section on the route
+		-- Note that the section ID is implicitly inferred from the TCB
+		1 = {
+			locks = { -- component locks for this section of the route.
+				800080008000 = st
+			}
+			next = S[(-23,9,0)/2] -- the start TCB of the next route segment (pointing forward)
+			-- Signal info: relates to the signal at the start of this section:
+			main_aspect = "_free" -- The main aspect that the route start signal is to show
+			assign_dst = false  -- Whether to assign distant signal (affects only the signal at the start of the route)
+								-- false: start signal does not set distant signal (the default), for long blocks
+								-- it is assumed that the next main signal will have its own distant sig
+								-- true: start signal sets distant signal to the next signal on the route with route_role "main" (typically the end signal)
+								-- for short blocks where end signal doesn't have its own distant sig
+			call_on = false	-- if true, when this route is set, section is allowed to be occupied by a train (but it must not have a route set in)
+		}
+		2 = {
+			locks = {}
+			-- if next is omitted, then there is no final TCB (e.g. a buffer)
+		}
+		name = "<the route name>"
+		ars = { <ARS rule definition table> }
+		use_rscache = false -- if true, the track section's rs_cache will be used to set locks in addition to the locks table
+							-- this is disabled for legacy routes, but enabled for all new routes by default
+		default_autoworking = false -- if true, when route is set autoworking will be by default on. Used for Blocksignal mode
+	}
+}
+
 Track section
 [id] = {
 	name = "Some human-readable name"
 	tc_breaks = { <signal specifier>,... } -- Bounding TC's (signal specifiers)
-	-- Can be direct ends (auto-detected), conflicting routes or TCBs that are too far away from each other
+	rs_cache = { [startTcbPosEnc] = { [endTcbPosEnc] = { [componentPosEnc] = "state" } } }
+	-- Saves the turnout states that need to be locked when a route is set from tcb#x to tcb#y
+	-- e.g. "800080008005" = { "800080007EEA" = { "800080008000" = "st" } }
+	--       start TCB           end TCB             switch pos
+	-- Recalculated on every change via update_rs_cache
+	-- Note that the tcb side number is not saved because it is unnecessary
+	fixed_locks = { "800080008000" = "st" }
+	-- table of fixed locks to be set for all routes thru this section (e.g. level crossings
+	
 	route = {
 		origin = <signal>,  -- route origin
 		entry = <sigd>,     -- supposed train entry point
@@ -224,7 +294,9 @@ Track section
 	-- first says whether to clear the routesetting status from the origin signal.
 	-- locks contains the positions where locks are held by this ts.
 	-- 'route' is cleared when train enters the section, while 'route_post' cleared when train leaves section.
+	
 	trains = {<id>, ...} -- Set whenever a train (or more) reside in this TC
+	-- Note: The same train ID may be contained in this mapping multiple times, when it has entered the section in two different places.
 }
 
 
@@ -237,24 +309,13 @@ signal_assignments = {
 }
 ]]
 
+-- Maximum scan length for track iterator
+local TS_MAX_SCAN = 1000
 
---
-function ildb.create_tcb(pos)
-	local new_tcb = {
-		[1] = {},
-		[2] = {},
-	}
-	local pts = advtrains.roundfloorpts(pos)
-	if not track_circuit_breaks[pts] then
-		track_circuit_breaks[pts] = new_tcb
-		return true
-	else
-		return false
-	end
-end
+-- basic functions
 
 function ildb.get_tcb(pos)
-	local pts = advtrains.roundfloorpts(pos)
+	local pts = advtrains.encode_pos(pos)
 	return track_circuit_breaks[pts]
 end
 
@@ -264,227 +325,635 @@ function ildb.get_tcbs(sigd)
 	return tcb[sigd.s]
 end
 
-
-function ildb.create_ts(sigd)
-	local tcbs = ildb.get_tcbs(sigd)
-	local id = advtrains.random_id()
-	
-	while track_sections[id] do
-		id = advtrains.random_id()
-	end
-	
-	track_sections[id] = {
-		name = tostring(id),
-		tc_breaks = { sigd }
-	}
-	tcbs.ts_id = id
-end
-
 function ildb.get_ts(id)
 	return track_sections[id]
 end
 
+-- retrieve full tables. Please use only read-only!
+function ildb.get_all_tcb()
+	return track_circuit_breaks
+end
+function ildb.get_all_ts()
+	return track_sections
+end
 
-
--- various helper functions handling sigd's
-local sigd_equal = advtrains.interlocking.sigd_equal
-local function insert_sigd_nodouble(list, sigd)
-	for idx, cmp in pairs(list) do
-		if sigd_equal(sigd, cmp) then
-			return
-		end
+function tsrepair_notify(notify_pname, ...)
+	if notify_pname then
+		minetest.chat_send_player(notify_pname, advtrains.print_concat_table({"TS Check:",...}))
 	end
-	table.insert(list, sigd)
 end
 
-
--- This function will actually handle the node that is in connid direction from the node at pos
--- so, this needs the conns of the node at pos, since these are already calculated
-local function traverser(found_tcbs, pos, conns, connid, count, brk_when_found_n)
-	local adj_pos, adj_connid, conn_idx, nextrail_y, next_conns = advtrains.get_adjacent_rail(pos, conns, connid, advtrains.all_tracktypes)
-	if not adj_pos then
-		--atdebug("Traverser found end-of-track at",pos, connid)
-		return
+-- Checks the consistency of the track section at the given position, attempts to autorepair track sections if they are inconsistent
+-- There are 2 operation modes:
+--		1: pos is NOT a TCB, tcb_connid MUST be nil
+-- 		2: pos is a TCB, tcb_connid MUST be given
+-- @param pos: the position to start from
+-- @param tcb_connid: If provided node is a TCB, the direction in which to search
+-- @param notify_pname: the player to notify about reparations
+-- Returns:
+-- ts_id - the track section that was found
+-- nil - No track section exists
+function ildb.check_and_repair_ts_at_pos(pos, tcb_connid, notify_pname, force_create)
+	--atdebug("check_and_repair_ts_at_pos", pos, tcb_connid)
+	-- check prereqs
+	if ildb.get_tcb(pos) then
+		if not tcb_connid then error("check_and_repair_ts_at_pos: Startpoint is TCB, must provide tcb_connid!") end
+	else
+		-- FIX 2025-01-07: If the checked pos is not a TCB, we always need to search in both directions, otherwise we errorneously split a ts
+		tcb_connid = nil
 	end
-	-- look whether there is a TCB here
-	if #next_conns == 2 then --if not, don't even try!
-		local tcb = ildb.get_tcb(adj_pos)
-		if tcb then
-			-- done with this branch
-			--atdebug("Traverser found tcb at",adj_pos, adj_connid)
-			insert_sigd_nodouble(found_tcbs, {p=adj_pos, s=adj_connid})
-			return
+	-- STEP 1: Ensure that only one section is at this place
+	-- get all TCBs adjacent to this 
+	local all_tcbs = ildb.get_all_tcbs_adjacent(pos, tcb_connid)
+	local first_ts = true
+	local ts_id
+	for _,sigd in ipairs(all_tcbs) do
+		ildb.tcbs_ensure_ts_ref_exists(sigd)
+		local tcbs_ts_id = sigd.tcbs.ts_id
+		if first_ts then
+			-- this one determines
+			ts_id = tcbs_ts_id
+			first_ts = false
+		else
+			-- these must be the same as the first
+			if ts_id ~= tcbs_ts_id then
+				-- inconsistency is found, repair it
+				--atdebug("check_and_repair_ts_at_pos: Inconsistency is found!")
+				tsrepair_notify(notify_pname, "Track section inconsistent here, repairing...")
+				return ildb.repair_ts_merge_all(all_tcbs, force_create, notify_pname)
+				-- Step2 check is no longer necessary since we just created that new section
+			end
 		end
 	end
-	-- recursion abort condition
-	if count > TRAVERSER_LIMIT then
-		--atdebug("Traverser hit counter at",adj_pos, adj_connid)
-		return true
-	end
-	-- continue traversing
-	local counter_hit = false
-	for nconnid, nconn in ipairs(next_conns) do
-		if adj_connid ~= nconnid then
-			counter_hit = counter_hit or traverser(found_tcbs, adj_pos, next_conns, nconnid, count + 1, brk_when_found_n)
-			if brk_when_found_n and #found_tcbs>=brk_when_found_n then
-				break
-			end
+	-- only one found (it is either nil or a ts id)
+	--atdebug("check_and_repair_ts_at_pos: TS consistent id=",ts_id,"")
+	if not ts_id then
+		if force_create and next(all_tcbs) then --ensure at least one tcb is in list
+			return ildb.repair_ts_merge_all(all_tcbs, force_create, notify_pname)
+		else
+			--tsrepair_notify(notify_pname, "No track section found here.")
+			return nil
+			-- All TCBs agreed that there is no section here
 		end
 	end
-	return counter_hit
+	
+	local ts = ildb.get_ts(ts_id)
+	if not ts then
+		-- This branch may never be reached, because ildb.tcbs_ensure_ts_ref_exists(sigd) is already supposed to clear out missing sections
+		error("check_and_repair_ts_at_pos: Resolved to nonexisting section although ildb.tcbs_ensure_ts_ref_exists(sigd) was supposed to prevent this. Panic!")
+	end
+	ildb.purge_ts_tcb_refs(ts_id)
+	-- STEP 2: Ensure that all_tcbs is equal to the track section's TCB list. If there are extra TCBs then the section should be split
+	-- ildb.tcbs_ensure_ts_ref_exists(sigd) has already make sure that all tcbs are found in the ts's tc_breaks list
+	-- That means it is sufficient to compare the LENGTHS of both lists, if one is longer then it is inconsistent
+	if #ts.tc_breaks ~= #all_tcbs then
+		--atdebug("check_and_repair_ts_at_pos: Partition is found!")
+		tsrepair_notify(notify_pname, "Track section partition found, repairing...")
+		return ildb.repair_ts_merge_all(all_tcbs, force_create, notify_pname)
+	end
+	--tsrepair_notify(notify_pname, "Found section", ts.name or ts_id, "here.")
+	ildb.update_rs_cache(ts_id)
+	return ts_id
 end
 
+-- Helper function to prevent duplicates
+local function insert_sigd_if_not_present(tab, sigd)
+	local found = false
+	for _, ssigd in ipairs(tab) do
+		if vector.equals(sigd.p, ssigd.p) and sigd.s==ssigd.s then
+			found = true
+		end
+	end
+	if not found then
+		table.insert(tab, sigd)
+	end
+	return not found
+end
 
-
--- Merges the TS with merge_id into root_id and then deletes merge_id
-local function merge_ts(root_id, merge_id)
-	local rts = ildb.get_ts(root_id)
-	local mts = ildb.get_ts(merge_id)
-	if not mts then return end -- This may be the case when sync_tcb_neighbors
-	-- inserts the same id twice. do nothing.
-	
-	if not ildb.may_modify_ts(rts) then return false end
-	if not ildb.may_modify_ts(mts) then return false end
-	
-	-- cobble together the list of TCBs
-	for _, msigd in ipairs(mts.tc_breaks) do
-		local tcbs = ildb.get_tcbs(msigd)
-		if tcbs then
-			insert_sigd_nodouble(rts.tc_breaks, msigd)
-			tcbs.ts_id = root_id
+-- Starting from a position, search all TCBs that can be reached from this position.
+-- In a non-faulty setup, all of these should have the same track section assigned.
+-- This function does not trigger a repair.
+-- @param inipos: the initial position
+-- @param inidir: the initial direction, or nil to search in all directions
+-- @param per_track_callback: A callback function called with signature (pos, connid, bconnid) for every track encountered
+-- Returns: a list of sigd's describing the TCBs found (sigd's point inward):
+-- 		{p=<pos>, s=<side>, tcbs=<ref to tcbs table>}
+function ildb.get_all_tcbs_adjacent(inipos, inidir, per_track_callback)
+	--atdebug("get_all_tcbs_adjacent: inipos",inipos,"inidir",inidir,"")
+	local found_sigd = {}
+	local ti = advtrains.get_track_iterator(inipos, inidir, TS_MAX_SCAN, true)
+	-- if initial start is TCBS and has xlink, need to add that to the TI
+	local inisi = {p=inipos, s=inidir};
+	local initcbs = ildb.get_tcbs(inisi)
+	if initcbs then
+		ildb.validate_tcb_xlink(inisi, true)
+		if initcbs.xlink then
+			-- adding the tcb will happen when this branch is retrieved again using ti:next_branch()
+			--atdebug("get_all_tcbs_adjacent: Putting xlink Branch for initial node",initcbs.xlink)
+			ti:add_branch(initcbs.xlink.p, initcbs.xlink.s)
 		end
-		advtrains.interlocking.show_tcb_marker(msigd.p)
 	end
-	-- done
-	track_sections[merge_id] = nil
+	local pos, connid, bconnid, tcb
+	while ti:has_next_branch() do
+		pos, connid = ti:next_branch()
+		--atdebug("get_all_tcbs_adjacent: BRANCH: ",pos, connid)
+		bconnid = nil
+		local is_branch_start = true
+		repeat
+			-- callback
+			if per_track_callback then
+				per_track_callback(pos, connid, bconnid)
+			end
+			tcb = ildb.get_tcb(pos)
+			if tcb then
+				local using_connid = bconnid
+				-- found a tcb
+				if is_branch_start then
+					-- A branch cannot be a TCB, as that would imply that it was a turnout/crossing (illegal)
+					-- UNLESS: (a) it is the start point or (b) it was added via xlink
+					-- Then the correct conn to use is connid (pointing forward)
+					--atdebug("get_all_tcbs_adjacent: Inserting TCB at branch start",pos, connid)
+					using_connid = connid
+				end
+				-- add the sigd of this tcb and a reference to the tcb table in it
+				--atdebug("get_all_tcbs_adjacent: Found TCB: ",pos, using_connid, "ts=", tcb[using_connid].ts_id)
+				local si = {p=pos, s=using_connid, tcbs=tcb[using_connid]}
+				-- if xlink exists, add it now (only if we are not in branch start)
+				ildb.validate_tcb_xlink(si, true)
+				if not is_branch_start and si.tcbs.xlink then
+					-- adding the tcb will happen when this branch is retrieved again using ti:next_branch()
+					--atdebug("get_all_tcbs_adjacent: Putting xlink Branch",si.tcbs.xlink)
+					ti:add_branch(si.tcbs.xlink.p, si.tcbs.xlink.s)
+				end
+				insert_sigd_if_not_present(found_sigd, si)
+				if not is_branch_start then
+					break
+				end
+			end
+			pos, connid, bconnid = ti:next_track()
+			is_branch_start = false
+			--atdebug("get_all_tcbs_adjacent: TRACK: ",pos, connid, bconnid)
+		until not pos
+	end
+	return found_sigd
 end
 
-local lntrans = { "A", "B" }
-local function sigd_to_string(sigd)
-	return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s]
+-- Called by frontend functions when multiple tcbs's that logically belong to one section have been determined to have different sections
+-- Parameter is the output of ildb.get_all_tcbs_adjacent(pos)
+-- Returns the ID of the track section that results after the merge
+function ildb.repair_ts_merge_all(all_tcbs, force_create, notify_pname)
+	--atdebug("repair_ts_merge_all: Instructed to merge sections of following TCBs:")
+	-- The first loop does the following for each TCBS:
+	-- a) Store the TS ID in the set of TS to update
+	-- b) Set the TS ID to nil, so that the TCBS gets removed from the section
+	local ts_to_update = {}
+	local ts_name_repo = {}
+	local any_ts = false
+	for _,sigd in ipairs(all_tcbs) do
+		local ts_id = sigd.tcbs.ts_id
+		--atdebug(sigd, "ts=", ts_id)
+		if ts_id then
+			local ts = track_sections[ts_id]
+			if ts then
+				any_ts = true
+				ts_to_update[ts_id] = true
+				-- if nonstandard name, store this
+				if ts.name and not string.match(ts.name, "^Section") then
+					ts_name_repo[#ts_name_repo+1] = ts.name
+				end
+			end
+		end
+		sigd.tcbs.ts_id = nil
+	end
+	if not any_ts and not force_create then
+		-- nothing to do at all, just no interlocking. Why were we even called
+		--atdebug("repair_ts_merge_all: No track section present, will not create a new one")
+		return nil
+	end
+	-- Purge every TS in turn. TS's that are now empty will be deleted. TS's that still have TCBs will be kept
+	for ts_id, _ in pairs(ts_to_update) do
+		local remain_ts = ildb.purge_ts_tcb_refs(ts_id)
+	end
+	-- Create a new fresh track section with all the TCBs we have in our collection
+	local new_ts_id, new_ts = ildb.create_ts_from_tcb_list(all_tcbs)
+	tsrepair_notify(notify_pname, "Created track section",new_ts_id,"from",#all_tcbs,"TCBs")
+	return new_ts_id
 end
 
--- Check for near TCBs and connect to their TS if they have one, and syncs their data.
-function ildb.sync_tcb_neighbors(pos, connid)
-	local found_tcbs = { {p = pos, s = connid} }
-	local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes)
-	if not node_ok then
-		atwarn("update_tcb_neighbors but node is NOK: "..minetest.pos_to_string(pos))
-		return
+-- For the specified TS, go through the list of TCBs and purge all TCBs that have no corresponding backreference in their TCBS table.
+-- If the track section ends up empty, it is deleted in this process.
+-- Should the track section still exist after the purge operation, it is returned.
+function ildb.purge_ts_tcb_refs(ts_id)
+	local ts = track_sections[ts_id]
+	if not ts then
+		return nil
 	end
-	
-	--atdebug("Traversing from ",pos, connid)
-	local counter_hit = traverser(found_tcbs, pos, conns, connid, 0)
-	
-	local ts_id
-	local list_eoi = {}
-	local list_ok = {}
-	local list_mismatch = {}
-	local ts_to_merge = {}
-	
-	for idx, sigd in pairs(found_tcbs) do
+	local has_changed = false
+	local i = 1
+	while ts.tc_breaks[i] do
+		-- get TCBS
+		local sigd = ts.tc_breaks[i]
 		local tcbs = ildb.get_tcbs(sigd)
-		if not tcbs.ts_id then
-			--atdebug("Sync: put",sigd_to_string(sigd),"into list_eoi")
-			table.insert(list_eoi, sigd)
-		elseif not ts_id and tcbs.ts_id then
-			if not ildb.get_ts(tcbs.ts_id) then
-				atwarn("Track section database is inconsistent, there's no TS with ID=",tcbs.ts_id)
-				tcbs.ts_id = nil
-				table.insert(list_eoi, sigd)
+		if tcbs then
+			if tcbs.ts_id == ts_id then
+				-- this one is legit
+				i = i+1
 			else
-				--atdebug("Sync: put",sigd_to_string(sigd),"into list_ok")
-				ts_id = tcbs.ts_id
-				table.insert(list_ok, sigd)
+				-- this one is to be purged
+				--atdebug("purge_ts_tcb_refs(",ts_id,"): purging",sigd,"(backreference = ",tcbs.ts_id,")")
+				table.remove(ts.tc_breaks, i)
+				has_changed = true
 			end
-		elseif ts_id and tcbs.ts_id and tcbs.ts_id ~= ts_id then
-			atwarn("Track section database is inconsistent, sections share track!")
-			atwarn("Merging",tcbs.ts_id,"into",ts_id,".")
-			table.insert(list_mismatch, sigd)
-			table.insert(ts_to_merge, tcbs.ts_id)
+		else
+			-- if not tcbs: was anyway an orphan, remove it
+			--atdebug("purge_ts_tcb_refs(",ts_id,"): purging",sigd,"(referred nonexisting TCB)")
+			table.remove(ts.tc_breaks, i)
+			has_changed = true
 		end
 	end
-	if ts_id then
-		local ts = ildb.get_ts(ts_id)
-		for _, sigd in ipairs(list_eoi) do
-			local tcbs = ildb.get_tcbs(sigd)
-			tcbs.ts_id = ts_id
-			table.insert(ts.tc_breaks, sigd)
-			advtrains.interlocking.show_tcb_marker(sigd.p)
-		end
-		for _, mts in ipairs(ts_to_merge) do
-			merge_ts(ts_id, mts)
+	if #ts.tc_breaks == 0 then
+		-- remove the section completely
+		--atdebug("purge_ts_tcb_refs(",ts_id,"): after purging, the section is empty, is being deleted")
+		track_sections[ts_id] = nil
+		return nil
+	else
+		if has_changed then
+			-- needs to update route cache
+			ildb.update_rs_cache(ts_id)
 		end
+		return ts
 	end
 end
 
-function ildb.link_track_sections(merge_id, root_id)
-	if merge_id == root_id then
+-- For the specified TCBS, make sure that the track section referenced by it
+-- (a) exists and
+-- (b) has a backreference to this TCBS stored in its tc_breaks list
+function ildb.tcbs_ensure_ts_ref_exists(sigd)
+	local tcbs = sigd.tcbs or ildb.get_tcbs(sigd)
+	if not tcbs or not tcbs.ts_id then return end
+	local ts = ildb.get_ts(tcbs.ts_id)
+	if not ts then
+		--atdebug("tcbs_ensure_ts_ref_exists(",sigd,"): TS does not exist, setting to nil")
+		-- TS is deleted, clear own ts id
+		tcbs.ts_id = nil
 		return
 	end
-	merge_ts(root_id, merge_id)
+	local did_insert = insert_sigd_if_not_present(ts.tc_breaks, {p=sigd.p, s=sigd.s})
+	if did_insert then
+		--atdebug("tcbs_ensure_ts_ref_exists(",sigd,"): TCBS was missing reference in TS",tcbs.ts_id)
+		ildb.update_rs_cache(tcbs.ts_id)
+	end
 end
 
-function ildb.remove_from_interlocking(sigd)
-	local tcbs = ildb.get_tcbs(sigd)
-	if not ildb.may_modify_tcbs(tcbs) then return false end
+function ildb.create_ts_from_tcb_list(sigd_list)
+	local id = advtrains.random_id(8)
 	
-	if tcbs.ts_id then
-		local tsid = tcbs.ts_id
-		local ts = ildb.get_ts(tsid)
-		if not ts then
-			tcbs.ts_id = nil
-			return true
+	while track_sections[id] do
+		id = advtrains.random_id(8)
+	end
+	--atdebug("create_ts_from_tcb_list: sigd_list=",sigd_list, "new ID will be ",id)
+
+	local tcbr = {}
+	-- makes a copy of the sigd list, for use in repair mechanisms where sigd may contain a tcbs field which we dont want
+	for _, sigd in ipairs(sigd_list) do
+		table.insert(tcbr, {p=sigd.p, s=sigd.s})
+		local tcbs = sigd.tcbs or ildb.get_tcbs(sigd)
+		if tcbs.ts_id then
+			error("Trying to create TS with TCBS that is already assigned to other section")
 		end
-		
-		-- remove entry from the list
-		local idx = 1
-		while idx <= #ts.tc_breaks do
-			local cmp = ts.tc_breaks[idx]
-			if sigd_equal(sigd, cmp) then
-				table.remove(ts.tc_breaks, idx)
+		tcbs.ts_id = id
+	end
+	
+	local new_ts = {
+		tc_breaks = tcbr
+	}
+	track_sections[id] = new_ts
+	-- update the TCB markers
+	for _, sigd in ipairs(sigd_list) do
+		advtrains.interlocking.show_tcb_marker(sigd.p)
+	end
+	
+	
+	ildb.update_rs_cache(id)
+	return id, new_ts
+end
+
+-- RS CACHE --
+
+--[[
+node_from_to_list - cache of from-to connid mappings and their associated state.
+Acts like a cache, built on demand by ildb.get_possible_out_connids(nodename)
+node_name = {
+	from_connid = {
+		to_connid = state
+	}
+}
+]]
+local node_from_to_state_cache = {}
+
+function ildb.get_possible_out_connids(node_name, in_connid)
+	if not node_from_to_state_cache[node_name] then
+		node_from_to_state_cache[node_name] = {}
+	end
+	local nt = node_from_to_state_cache[node_name]
+	if not nt[in_connid] then
+		local ta = {}
+		--atdebug("Node From/To State Cache: Caching for ",node_name,"connid",in_connid)
+		local ndef = minetest.registered_nodes[node_name]
+		if ndef.advtrains.node_state_map then
+			for state, tnode in pairs(ndef.advtrains.node_state_map) do
+				local tndef = minetest.registered_nodes[tnode]
+				-- verify that the conns table is identical - this is purely to catch setup errors!
+				if not tndef.at_conns or not tndef.at_conn_map then
+					--atdebug("ndef:",ndef,", tndef:",tndef)
+					error("In AT setup for node "..tnode..": Node set as state "..state.." of "..node_name.." in state_map, but is missing at_conns/at_conn_map!")
+				end
+				if #ndef.at_conns ~= #tndef.at_conns then
+					--atdebug("ndef:",ndef,", tndef:",tndef)
+					error("In AT setup for node "..tnode..": Conns table does not match that of "..node_name.." (of which this is state "..state..")")
+				end
+				for connid=1,#ndef.at_conns do
+					if ndef.at_conns[connid].c ~= tndef.at_conns[connid].c then
+						--atdebug("ndef:",ndef,", tndef:",tndef)
+						error("In AT setup for node "..tnode..": Conns table does not match that of "..node_name.." (of which this is state "..state..")")
+					end
+				end
+				-- do the actual caching by looking at the conn_map
+				local target_connid = tndef.at_conn_map[in_connid]
+				if ta[target_connid] then
+					-- Select the variant for which the other way would back-connect. This way, turnouts will switch to the appropriate branch if the train joins
+					local have_back_conn = (tndef.at_conn_map[target_connid])==in_connid
+					--atdebug("Found second state mapping",in_connid,"-",target_connid,"have_back_conn=",have_back_conn)
+					if have_back_conn then
+						--atdebug("Overwriting",in_connid,"-",target_connid,"=",state)
+						ta[target_connid] = state
+					end
+				else
+					--atdebug("Setting",in_connid,"-",target_connid,"=",state)
+					ta[target_connid] = state
+				end
+			end
+		else
+			error("Node From/To State Cache: "..node_name.." doesn't have a state map, is not a switchable track! Panic!")
+		end
+		nt[in_connid] = ta
+	end
+	return nt[in_connid]
+end
+
+local function recursively_find_routes(s_pos, s_connid, locks_found, result_table, scan_limit)
+	--atdebug("Recursively restarting at ",s_pos, s_connid, "limit left", scan_limit)
+	local ti = advtrains.get_track_iterator(s_pos, s_connid, scan_limit, false)
+	local pos, connid, bconnid = ti:next_branch()
+	pos, connid, bconnid = ti:next_track()-- step once to get ahead of previous turnout
+	local last_pos
+	while pos do -- this stops the loop when either the track end is reached or the limit is hit
+		local node = advtrains.ndb.get_node_or_nil(pos)
+		--atdebug("Walk ",pos, "nodename", node.name, "entering at conn",bconnid)
+		local ndef = minetest.registered_nodes[node.name]
+		if ndef.advtrains and ndef.advtrains.node_state_map then
+			-- Stop, this is a switchable node. Find out which conns we can go at
+			--atdebug("Found turnout ",pos, "nodename", node.name, "entering at conn",bconnid)
+			local pts = advtrains.encode_pos(pos)
+			if locks_found[pts] then
+				-- we've been here before. Stop
+				--atdebug("Was already seen! returning")
+				return
+			end
+			local out_conns = ildb.get_possible_out_connids(node.name, bconnid)
+			-- note 2025-01-06: get_possible_out_connids contains some logic so that the correct switch state is selected even if the turnout is entered from the branch side (see "have_back_conn")
+			for oconnid, state in pairs(out_conns) do
+				--atdebug("Going in direction",oconnid,"state",state)
+				locks_found[pts] = state
+				recursively_find_routes(pos, oconnid, locks_found, result_table, ti.limit)
+				locks_found[pts] = nil
+			end
+			return
+		end
+		--otherwise, this might be a tcb
+		local tcb = ildb.get_tcb(pos)
+		if tcb then
+			-- we found a tcb, store the current locks in the result_table
+			local end_pkey = advtrains.encode_pos(pos)
+			--atdebug("Found end TCB", pos, end_pkey,", returning")
+			if result_table[end_pkey] then
+				atwarn("While caching track section routing, found multiple route paths within same track section. Only first one found will be used")
 			else
-				idx = idx + 1
+				result_table[end_pkey] = table.copy(locks_found)
 			end
+			return
 		end
-		tcbs.ts_id = nil
-		
-		--ildb.sync_tcb_neighbors(sigd.p, sigd.s)
+		-- Go forward
+		last_pos = pos
+		pos, connid, bconnid = ti:next_track()
+	end 
+	--atdebug("recursively_find_routes: Reached track end or limit at", last_pos, ". This path is not saved, returning")
+end
+
+-- Updates the turnout cache of the given track section
+function ildb.update_rs_cache(ts_id)
+	local ts = ildb.get_ts(ts_id)
+	if not ts then
+		error("Update TS Cache called with nonexisting ts_id "..(ts_id or "nil"))
+	end
+	local rscache = {}
+	--atdebug("== Running update_rs_cache for ",ts_id) 
+	-- start on every of the TS's TCBs, walk the track forward and store locks along the way
+	for start_tcbi, start_tcbs in ipairs(ts.tc_breaks) do
+		start_pkey = advtrains.encode_pos(start_tcbs.p)
+		rscache[start_pkey] = {}
+		--atdebug("Starting for ",start_tcbi, start_tcbs)
+		local locks_found = {}
+		local result_table = {}
 		
-		if #ts.tc_breaks == 0 then
-			track_sections[tsid] = nil
+		recursively_find_routes(start_tcbs.p, start_tcbs.s, locks_found, result_table, TS_MAX_SCAN)
+		-- now result_table contains found route locks. Match them with the other TCBs we have in this section
+		for end_tcbi, end_tcbs in ipairs(ts.tc_breaks) do
+			if end_tcbi ~= start_tcbi then
+				end_pkey = advtrains.encode_pos(end_tcbs.p)
+				if result_table[end_pkey] then
+					--atdebug("Set RSCache entry",end_pkey.."-"..end_pkey,"=",result_table[end_pkey])
+					local lockstab = result_table[end_pkey]
+					if ts.fixed_locks then -- include the sections fixedlocks if present
+						for pts, st in pairs(ts.fixed_locks) do lockstab[pts] = st end
+					end
+					rscache[start_pkey][end_pkey] = lockstab
+					result_table[end_pkey] = nil
+				end
+			end
+		end
+		-- warn about superfluous entry
+		for sup_end_pkey, sup_entry in pairs(result_table) do
+			atwarn("In update_rs_cache for section",ts_id,"found superfluous endpoint",sup_end_pkey,"->",sup_entry)
 		end
 	end
-	advtrains.interlocking.show_tcb_marker(sigd.p)
-	if tcbs.signal then
-		return false
-	end
-	return true
+	ts.rs_cache = rscache
+	--atdebug("== Done update_rs_cache for ",ts_id, "result:",rscache) 
 end
 
-function ildb.remove_tcb(pos)
-	local pts = advtrains.roundfloorpts(pos)
-	if not track_circuit_breaks[pts] then
-		return true --FIX: not an error, because tcb is already removed
-	end
+
+--- DB API functions
+
+local lntrans = { "A", "B" }
+function ildb.sigd_to_string(sigd)
+	return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s]
+end
+
+-- Create a new TCB at the position and update/repair the adjoining sections
+function ildb.create_tcb_at(pos)
+	--atdebug("create_tcb_at",pos)
+	local pts = advtrains.encode_pos(pos)
+	track_circuit_breaks[pts] = {[1] = {}, [2] = {}}
+	local all_tcbs_1 = ildb.get_all_tcbs_adjacent(pos, 1)
+	--atdebug("TCBs on A side",all_tcbs_1)
+	local all_tcbs_2 = ildb.get_all_tcbs_adjacent(pos, 2)
+	--atdebug("TCBs on B side",all_tcbs_2)
+	-- perform TS repair
+	ildb.repair_ts_merge_all(all_tcbs_1, false)
+	ildb.repair_ts_merge_all(all_tcbs_2, false)
+end
+
+-- Remove TCB at the position and update/repair the now joined section
+--   skip_tsrepair: should be set to true when the rail node at the TCB position is already gone.
+--                  Assumes the track sections are now separated and does not attempt the repair process.
+function ildb.remove_tcb_at(pos, pname, skip_tsrepair)
+	--atdebug("remove_tcb_at",pos)
+	local pts = advtrains.encode_pos(pos)
+	local old_tcb = track_circuit_breaks[pts]
+	-- unassign signals if defined
 	for connid=1,2 do
-		if not ildb.remove_from_interlocking({p=pos, s=connid}) then
-			return false
+		if old_tcb[connid].signal then
+			ildb.set_sigd_for_signal(old_tcb[connid].signal, nil)
 		end
 	end
 	track_circuit_breaks[pts] = nil
+	-- purge the track sections adjacent
+	if old_tcb[1].ts_id then
+		ildb.purge_ts_tcb_refs(old_tcb[1].ts_id)
+	end
+	if old_tcb[2].ts_id then
+		ildb.purge_ts_tcb_refs(old_tcb[2].ts_id)
+	end
+	-- update xlink partners
+	if old_tcb[1].xlink then
+		ildb.validate_tcb_xlink(old_tcb[1].xlink)
+	end
+	if old_tcb[2].xlink then
+		ildb.validate_tcb_xlink(old_tcb[2].xlink)
+	end
+	advtrains.interlocking.remove_tcb_marker(pos)
+	-- If needed, merge the track sections here
+	if not skip_tsrepair then
+		ildb.check_and_repair_ts_at_pos(pos, nil, pname)
+	end
 	return true
 end
 
-function ildb.dissolve_ts(ts_id)
-	local ts = ildb.get_ts(ts_id)
-	if not ildb.may_modify_ts(ts) then return false end
-	local tcbr = advtrains.merge_tables(ts.tc_breaks)
-	for _,sigd in ipairs(tcbr) do
-		ildb.remove_from_interlocking(sigd)
+-- Xlink: Connecting not-physically-connected sections handling
+
+-- Ensures that the xlink of this tcbs is bidirectional
+function ildb.validate_tcb_xlink(sigd, suppress_repairs)
+	local tcbs = sigd.tcbs or ildb.get_tcbs(sigd)
+	local osigd = tcbs.xlink
+	if not osigd then return end
+	local otcbs = ildb.get_tcbs(tcbs.xlink)
+	if not otcbs then
+		--atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd,"orphaned")
+		tcbs.xlink = nil
+		if not suppress_repairs then
+			ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s)
+		end
+		return
 	end
-	-- Note: ts gets removed in the moment of the removal of the last TCB.
-	return true
+	if otcbs.xlink then
+		if not vector.equals(otcbs.xlink.p, sigd.p) or otcbs.xlink.s~=sigd.s then
+			--atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd,"backreferencing to someone else (namely",otcbs.xlink,") clearing it")
+			tcbs.xlink = nil
+			if not suppress_repairs then
+				ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s)
+				--atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd," was backreferencing to someone else, now updating that")
+				ildb.validate_tcb_xlink(osigd)
+			end
+		end
+	else
+		--atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd,"wasn't backreferencing, clearing it")
+		tcbs.xlink = nil
+		if not suppress_repairs then
+			ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s)
+		end
+	end
+end
+
+function ildb.add_tcb_xlink(sigd1, sigd2)
+	--("add_tcb_xlink",sigd1, sigd2)
+	local tcbs1 = sigd1.tcbs or ildb.get_tcbs(sigd1)
+	local tcbs2 = sigd2.tcbs or ildb.get_tcbs(sigd2)
+	if vector.equals(sigd1.p, sigd2.p) then
+		--atdebug("add_tcb_xlink Cannot xlink with same TCB")
+		return
+	end
+	if not tcbs1 or not tcbs2 then
+		--atdebug("add_tcb_xlink TCBS doesnt exist")
+		return
+	end
+	if tcbs1.xlink or tcbs2.xlink then
+		--atdebug("add_tcb_xlink One already linked")
+		return
+	end
+	-- apply link
+	tcbs1.xlink = {p=sigd2.p, s=sigd2.s}
+	tcbs2.xlink = {p=sigd1.p, s=sigd1.s}
+	-- update section. It should be sufficient to call update only once because the TCBs are linked anyway now
+	ildb.check_and_repair_ts_at_pos(sigd1.p, sigd1.s)
+end
+
+function ildb.remove_tcb_xlink(sigd)
+	--atdebug("remove_tcb_xlink",sigd)
+	-- Validate first. If Xlink is gone already then, nothing to do
+	ildb.validate_tcb_xlink(sigd)
+	-- Checking all of these already done by validate
+	local tcbs = sigd.tcbs or ildb.get_tcbs(sigd)
+	local osigd = tcbs.xlink
+	if not osigd then
+		-- validate already cleared us
+		--atdebug("remove_tcb_xlink: Already gone by validate")
+		return
+	end
+	local otcbs = ildb.get_tcbs(tcbs.xlink)
+	-- clear it
+	otcbs.xlink = nil
+	tcbs.xlink = nil
+	-- Update section for ourself and the other one
+	ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s)
+	ildb.check_and_repair_ts_at_pos(osigd.p, osigd.s)
+end
+
+function ildb.create_ts_from_tcbs(sigd)
+	--atdebug("create_ts_from_tcbs",sigd)
+	local all_tcbs = ildb.get_all_tcbs_adjacent(sigd.p, sigd.s)
+	ildb.repair_ts_merge_all(all_tcbs, true)
+end
+
+-- Remove the given track section, leaving its TCBs with no section assigned
+function ildb.remove_ts(ts_id)
+	--atdebug("remove_ts",ts_id)
+	local ts = track_sections[ts_id]
+	if not ts then
+		error("remove_ts: "..ts_id.." doesn't exist")
+	end
+	while ts.tc_breaks[i] do
+		-- get TCBS
+		local sigd = ts.tc_breaks[i]
+		local tcbs = ildb.get_tcbs(sigd)
+		if tcbs then
+			--atdebug("cleared TCB",sigd)
+			tcbs.ts_id = nil
+		else
+			--atdebug("orphan TCB",sigd)
+		end
+		i = i+1
+	end
+	track_sections[ts_id] = nil
 end
 
 -- Returns true if it is allowed to modify any property of a track section, such as
@@ -509,38 +978,8 @@ function ildb.may_modify_tcbs(tcbs)
 	return true
 end
 
--- Utilize the traverser to find the track section at the specified position
--- Returns:
--- ts_id, origin - the first found ts and the sigd of the found tcb
--- nil - there were no TCBs in TRAVERSER_MAX range of the position
--- false - the first found TCB stated End-Of-Interlocking, or track ends were reached
-function ildb.get_ts_at_pos(pos)
-	local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes)
-	if not node_ok then
-		error("get_ts_at_pos but node is NOK: "..minetest.pos_to_string(pos))
-	end
-	local limit_hit = false
-	local found_tcbs = {}
-	for connid, conn in ipairs(conns) do -- Note: a breadth-first-search would be better for performance
-		limit_hit = limit_hit or traverser(found_tcbs, pos, conns, connid, 0, 1)
-		if #found_tcbs >= 1 then
-			local tcbs = ildb.get_tcbs(found_tcbs[1])
-			local ts
-			if tcbs.ts_id then
-				return tcbs.ts_id, found_tcbs[1]
-			else
-				return false
-			end
-		end
-	end
-	if limit_hit then
-		-- there was at least one limit hit
-		return nil
-	else
-		-- all traverser ends were track ends
-		return false
-	end
-end
+
+-- Signals/IP --
 
 
 -- returns the sigd the signal at pos belongs to, if this is known
@@ -556,11 +995,34 @@ function ildb.get_sigd_for_signal(pos)
 	end
 	return nil
 end
-function ildb.set_sigd_for_signal(pos, sigd)
+function ildb.set_sigd_for_signal(pos, sigd) -- do not use!
 	local pts = advtrains.roundfloorpts(pos)
 	signal_assignments[pts] = sigd
 end
 
+-- Assign the signal at pos to the given TCB side.
+function ildb.assign_signal_to_tcbs(pos, sigd)
+	local tcbs = ildb.get_tcbs(sigd)
+	assert(tcbs, "assign_signal_to_tcbs invalid sigd!")
+	tcbs.signal = pos
+	if not tcbs.routes then
+		tcbs.routes = {}
+	end
+	ildb.set_sigd_for_signal(pos, sigd)
+end
+
+-- unassign the signal from the given sigd (looks in tcbs.signal for the signalpos)
+function ildb.unassign_signal_for_tcbs(sigd)
+	local tcbs = advtrains.interlocking.db.get_tcbs(sigd)
+	if not tcbs then return end
+	local pos = tcbs.signal
+	if not pos then return end
+	ildb.set_sigd_for_signal(pos, nil)
+	tcbs.signal = nil
+	tcbs.route_aspect = nil
+	tcbs.route_remote = nil
+end
+
 -- checks if there's any influence point set to this position
 -- if purge is true, checks whether the associated signal still exists
 -- and deletes the ip if not.
@@ -570,7 +1032,7 @@ function ildb.is_ip_at(pos, purge)
 		if purge then
 			-- is there still a signal assigned to it?
 			for connid, sigpos in pairs(influence_points[pts]) do
-				local asp = advtrains.interlocking.signal_get_aspect(sigpos)
+				local asp = advtrains.interlocking.signal.get_aspect_info(sigpos)
 				if not asp then
 					atlog("Clearing orphaned signal influence point", pts, "/", connid)
 					ildb.clear_ip_signal(pts, connid)
@@ -597,7 +1059,7 @@ end
 function ildb.get_ip_signal_asp(pts, connid)
 	local p = ildb.get_ip_signal(pts, connid)
 	if p then
-		local asp = advtrains.interlocking.signal_get_aspect(p)
+		local asp = advtrains.interlocking.signal.get_aspect_info(p)
 		if not asp then
 			atlog("Clearing orphaned signal influence point", pts, "/", connid)
 			ildb.clear_ip_signal(pts, connid)
diff --git a/advtrains_interlocking/demosignals.lua b/advtrains_interlocking/demosignals.lua
deleted file mode 100644
index 98fa421..0000000
--- a/advtrains_interlocking/demosignals.lua
+++ /dev/null
@@ -1,104 +0,0 @@
--- Demonstration signals
--- Those can display the 3 main aspects of Ks signals
-
--- Note that the group value of advtrains_signal is 2, which means "step 2 of signal capabilities"
--- advtrains_signal=1 is meant for signals that do not implement set_aspect.
-
-
-local setaspect = function(pos, node, asp)
-	if asp.main == 0 then
-		advtrains.ndb.swap_node(pos, {name="advtrains_interlocking:ds_danger"})
-	else
-		if asp.dst ~= 0 and asp.main == -1 then
-			advtrains.ndb.swap_node(pos, {name="advtrains_interlocking:ds_free"})
-		else
-			advtrains.ndb.swap_node(pos, {name="advtrains_interlocking:ds_slow"})
-		end
-	end
-	local meta = minetest.get_meta(pos)
-	if meta then
-		meta:set_string("infotext", minetest.serialize(asp))
-	end
-end
-
-local suppasp = {
-		main = {0, 6, -1},
-		dst = {0, false},
-		shunt = false,
-		proceed_as_main = true,
-		info = {
-			call_on = false,
-			dead_end = false,
-			w_speed = nil,
-		}
-}
-
-minetest.register_node("advtrains_interlocking:ds_danger", {
-	description = attrans("Demo signal at Danger"),
-	tiles = {"at_il_signal_asp_danger.png"},
-	groups = {
-		cracky = 3,
-		advtrains_signal = 2,
-		save_in_at_nodedb = 1,
-	},
-	advtrains = {
-		set_aspect = setaspect,
-		supported_aspects = suppasp,
-		get_aspect = function(pos, node)
-			return advtrains.interlocking.DANGER
-		end,
-	},
-	on_rightclick = advtrains.interlocking.signal_rc_handler,
-	can_dig = advtrains.interlocking.signal_can_dig,
-	after_dig_node = advtrains.interlocking.signal_after_dig,
-})
-minetest.register_node("advtrains_interlocking:ds_free", {
-	description = attrans("Demo signal at Free"),
-	tiles = {"at_il_signal_asp_free.png"},
-	groups = {
-		cracky = 3,
-		advtrains_signal = 2,
-		save_in_at_nodedb = 1,
-	},
-	advtrains = {
-		set_aspect = setaspect,
-		supported_aspects = suppasp,
-		get_aspect = function(pos, node)
-			return {
-				main = -1,
-			}
-		end,
-	},
-	on_rightclick = advtrains.interlocking.signal_rc_handler,
-	can_dig = advtrains.interlocking.signal_can_dig,
-	after_dig_node = advtrains.interlocking.signal_after_dig,
-})
-minetest.register_node("advtrains_interlocking:ds_slow", {
-	description = attrans("Demo signal at Slow"),
-	tiles = {"at_il_signal_asp_slow.png"},
-	groups = {
-		cracky = 3,
-		advtrains_signal = 2,
-		save_in_at_nodedb = 1,
-	},
-	advtrains = {
-		set_aspect = setaspect,
-		supported_aspects = suppasp,
-		get_aspect = function(pos, node)
-			return {
-				main = 6,
-			}
-		end,
-	},
-	on_rightclick = advtrains.interlocking.signal_rc_handler,
-	can_dig = advtrains.interlocking.signal_can_dig,
-	after_dig_node = advtrains.interlocking.signal_after_dig,
-})
-
-minetest.register_craft({
-	output = "advtrains_interlocking:ds_danger",
-	recipe = {
-		{"bakedclay:black", "dye:red"},
-		{"default:glass", "default:glass"},
-	},
-})
diff --git a/advtrains_interlocking/init.lua b/advtrains_interlocking/init.lua
index ae73a37..596641e 100644
--- a/advtrains_interlocking/init.lua
+++ b/advtrains_interlocking/init.lua
@@ -2,7 +2,6 @@ ch_base.open_mod(minetest.get_current_modname())
 -- Advtrains interlocking system
 -- See database.lua for a detailed explanation
 
-
 advtrains.interlocking = {}
 
 advtrains.SHUNT_SPEED_MAX = 6
@@ -16,16 +15,19 @@ local modpath = minetest.get_modpath(minetest.get_current_modname()) .. DIR_DELI
 
 dofile(modpath.."database.lua")
 dofile(modpath.."signal_api.lua")
-dofile(modpath.."demosignals.lua")
+dofile(modpath.."signal_aspect_ui.lua")
 dofile(modpath.."train_sections.lua")
 dofile(modpath.."route_prog.lua")
 dofile(modpath.."routesetting.lua")
 dofile(modpath.."tcb_ts_ui.lua")
 dofile(modpath.."route_ui.lua")
+dofile(modpath.."smartroute.lua")
+dofile(modpath.."autonaming.lua")
 dofile(modpath.."tool.lua")
 
 dofile(modpath.."approach.lua")
 dofile(modpath.."ars.lua")
+
 dofile(modpath.."tsr_rail.lua")
 
 
diff --git a/advtrains_interlocking/mod.conf b/advtrains_interlocking/mod.conf
index 3b2d029..9191dd9 100644
--- a/advtrains_interlocking/mod.conf
+++ b/advtrains_interlocking/mod.conf
@@ -4,4 +4,4 @@ description=Interlocking system for Advanced Trains
 author=orwell96
 
 depends=advtrains
-optional_depends=advtrains_train_track
+#optional_depends=advtrains_train_track
diff --git a/advtrains_interlocking/route_prog.lua b/advtrains_interlocking/route_prog.lua
index cdc98c0..e0634d4 100644
--- a/advtrains_interlocking/route_prog.lua
+++ b/advtrains_interlocking/route_prog.lua
@@ -19,6 +19,11 @@ C. punch a turnout (or some other passive component) to fix its state (toggle)
 The route visualization will also be used to visualize routes after they have been programmed.
 ]]--
 
+-- TODO duplicate
+local lntrans = { "A", "B" }
+local function sigd_to_string(sigd)
+	return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s]
+end
 
 -- table with objectRefs
 local markerent = {}
@@ -108,15 +113,7 @@ end
 
 --[[
 Route definition:
-route = {
-	name = <string>
-	[n] = {
-		next = <sigd>, -- of the next (note: next) TCB on the route
-		locks = {<pts> = "state"} -- route locks of this route segment
-	}
-	terminal = <sigd>,
-	aspect = <signal aspect>,--note, might change in future
-}
+=== See database.lua L238
 The first item in the TCB path (namely i=0) is always the start signal of this route,
 so this is left out.
 All subsequent entries, starting from 1, contain:
@@ -206,7 +203,7 @@ function advtrains.interlocking.visualize_route(origin, route, context, tmp_lcks
 		end
 	-- display locks set by player		
 		for pts, state in pairs(tmp_lcks) do
-			local pos = minetest.string_to_pos(pts)
+			local pos = advtrains.decode_pos(pts)
 			routesprite(context, pos, "fixp"..pts, "at_il_route_lock_edit.png", "Zajištěna ve stavu '"..state.."' cestou "..route.name.." (levý klik pro uvolnění)",
 				function() clear_lock(tmp_lcks, pname, pts) end)
 		end
@@ -216,20 +213,33 @@ end
 
 local player_rte_prog = {}
 
-function advtrains.interlocking.init_route_prog(pname, sigd)
+function advtrains.interlocking.init_route_prog(pname, sigd, default_route)
 	if not minetest.check_player_privs(pname, "interlocking") then
-		minetest.chat_send_player(pname, attrans("Insufficient privileges to use this!"))
+		minetest.chat_send_player(pname, "Insufficient privileges to use this!")
 		return
 	end
-	player_rte_prog[pname] = {
+	local rp = {
 		origin = sigd,
-		route = {
-			name = "PROG["..pname.."]",
-		},
-		tmp_lcks = {},
 	}
-	advtrains.interlocking.visualize_route(sigd, player_rte_prog[pname].route, "prog_"..pname, player_rte_prog[pname].tmp_lcks, pname)
-	minetest.chat_send_player(pname, "Režim programování cesty je aktivní. Klikejte levým tlačítkem na TCB pro přidání úseků a na výhybky pro jejich uzamčení.")
+	if default_route then
+		rp.route = table.copy(default_route)
+
+		-- "Step back one section", but keeping turnouts
+		local last_route = rp.route[#rp.route]
+		if last_route then
+			rp.tmp_lcks = last_route.locks
+			rp.route[#rp.route] = nil
+		end
+		rp.route.name = "PROG["..pname.."]"
+	else
+		rp.route = {
+			name = "PROG["..pname.."]"
+		}
+		rp.tmp_lcks = {}
+	end
+	player_rte_prog[pname] = rp
+	advtrains.interlocking.visualize_route(sigd, rp.route, "prog_"..pname, rp.tmp_lcks, pname)
+	minetest.chat_send_player(pname, "Route programming mode active. Punch TCBs to add route segments, punch turnouts to lock them.")
 end
 
 local function get_last_route_item(origin, route)
@@ -239,10 +249,10 @@ local function get_last_route_item(origin, route)
 	return route[#route].next
 end
 
-local function do_advance_route(pname, rp, sigd, tsname)
+local function do_advance_route(pname, rp, sigd, tsref)
 	table.insert(rp.route, {next = sigd, locks = rp.tmp_lcks})
 	rp.tmp_lcks = {}
-	chat(pname, "Úsek '"..tsname.."' přidán na cestu.")
+	chat(pname, "Úsek '"..(tsref and (tsref.name or "") or "--EOI--").."' přidán na cestu.")
 end
 
 local function finishrpform(pname)
@@ -425,20 +435,20 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 			if fields.advance then
 				-- advance route
 				if not is_endpoint then
-					do_advance_route(pname, rp, this_sigd, this_ts.name)
+					do_advance_route(pname, rp, this_sigd, this_ts)
 				end
 			end
 			if fields.endhere then
 				if not is_endpoint then
-					do_advance_route(pname, rp, this_sigd, this_ts.name)
+					do_advance_route(pname, rp, this_sigd, this_ts)
 				end
 				finishrpform(pname)
 			end
 			if can_over and fields.endover then
 				if not is_endpoint then
-					do_advance_route(pname, rp, this_sigd, this_ts.name)
+					do_advance_route(pname, rp, this_sigd, this_ts)
 				end
-				do_advance_route(pname, rp, over_sigd, over_ts and over_ts.name or "--EOI--")
+				do_advance_route(pname, rp, over_sigd, over_ts)
 				finishrpform(pname)
 			end
 		end
@@ -488,6 +498,8 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 			local terminal = get_last_route_item(rp.origin, rp.route)
 			rp.route.terminal = terminal
 			rp.route.name = fields.name
+			-- new routes now always use the rscache
+			rp.route.use_rscache = true
 			
 			table.insert(tcbs.routes, rp.route)
 			
@@ -524,13 +536,16 @@ minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 			-- show formspec
 			
 			show_routing_form(pname, tcbpos)
-			
 			advtrains.interlocking.visualize_route(rp.origin, rp.route, "prog_"..pname, rp.tmp_lcks, pname)
-			
+			return
+		elseif advtrains.interlocking.db.get_tcb(pos) then
+			-- the punched node itself is a TCB
+			show_routing_form(pname, pos)
+			advtrains.interlocking.visualize_route(rp.origin, rp.route, "prog_"..pname, rp.tmp_lcks, pname)
 			return
 		end
 		if advtrains.is_passive(pos) then
-			local pts = advtrains.roundfloorpts(pos)
+			local pts = advtrains.encode_pos(pos)
 			if rp.tmp_lcks[pts] then
 				clear_lock(rp.tmp_lcks, pname, pts)
 			else
diff --git a/advtrains_interlocking/route_ui.lua b/advtrains_interlocking/route_ui.lua
index 0903b27..3fb5bc6 100644
--- a/advtrains_interlocking/route_ui.lua
+++ b/advtrains_interlocking/route_ui.lua
@@ -3,6 +3,7 @@
 
 local atil = advtrains.interlocking
 local ildb = atil.db
+local F = advtrains.formspec
 
 -- TODO duplicate
 local lntrans = { "A", "B" }
@@ -10,9 +11,10 @@ local function sigd_to_string(sigd)
 	return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s]
 end
 
+-- indexed by pname
+local sel_rpartcache = {}
 
-
-function atil.show_route_edit_form(pname, sigd, routeid)
+function atil.show_route_edit_form(pname, sigd, routeid, sel_rpartidx)
 
 	if not minetest.check_player_privs(pname, {train_operator=true, interlocking=true}) then
 		minetest.chat_send_player(pname, attrans("Insufficient privileges to use this!"))
@@ -30,16 +32,18 @@ function atil.show_route_edit_form(pname, sigd, routeid)
 	
 	-- construct textlist for route information
 	local tab = {}
-	local function itab(t)
+	local tabref = {}
+	local function itab(rseg, t, rty, rpara)
 		tab[#tab+1] = minetest.formspec_escape(string.gsub(t, ",", " "))
+		tabref[#tab] = { [rty] = true, param = rpara, seg = rseg, idx = #tab }
 	end
-	itab("TCB "..sigd_to_string(sigd).." ("..tcbs.signal_name..") Route #"..routeid)
+	itab(1, "("..(tcbs.signal_name or "+")..") Route #"..routeid, "signal", sigd)
 	
 	-- this code is partially copy-pasted from routesetting.lua
 	-- we start at the tc designated by signal
 	local c_sigd = sigd
 	local i = 1
-	local c_tcbs, c_ts_id, c_ts, c_rseg, c_lckp
+	local c_tcbs, c_ts_id, c_ts, c_rseg
 	while c_sigd and i<=#route do
 		c_tcbs = ildb.get_tcbs(c_sigd)
 		if not c_tcbs then
@@ -54,50 +58,127 @@ function atil.show_route_edit_form(pname, sigd, routeid)
 		c_ts = ildb.get_ts(c_ts_id)
 		
 		c_rseg = route[i]
-		c_lckp = {}
 		
-		itab(""..i.." Vjezd "..sigd_to_string(c_sigd).." -> Ús. "..(c_ts and c_ts.name or "-").." -> Výjezd "..(c_rseg.next and sigd_to_string(c_rseg.next) or "KONEC"))
+		local signame = "-"
+		if c_tcbs and c_tcbs.signal then signame = c_tcbs.signal_name or "o" end
+		itab(i, ""..i.." "..sigd_to_string(c_sigd).." ("..signame..")", "signal", c_sigd)
+		itab(i, "= "..(c_ts and c_ts.name or c_ts_id).." ="..(c_rseg.call_on and " [CO]" or ""), "section", c_ts_id)
 		
 		if c_rseg.locks then
 			for pts, state in pairs(c_rseg.locks) do
 				
-				local pos = minetest.string_to_pos(pts)
-				itab("  Zámek: "..pts.." -> "..state)
+				local pos = advtrains.decode_pos(pts)
+				itab(i, "Zámek "..pts.." -> "..state, "lock", pos)
 				if not advtrains.is_passive(pos) then
 					itab("-!- Na "..pts.." není žádná pasivní komponenta. Prosím, přenastavte cestu!")
 					break
 				end
 			end
 		end
+		-- sanity check, is section at next the same as the current?
+		local nvar = c_rseg.next
+		if nvar then
+			local re_tcbs = ildb.get_tcbs({p = nvar.p, s = (nvar.s==1) and 2 or 1})
+			if not re_tcbs or not re_tcbs.ts_id or re_tcbs.ts_id~=c_ts_id then
+				itab(i, "-!- At "..sigd_to_string(c_sigd)..".Section Start and End do not match!", "err", nil)
+				break
+			end
+		end
 		-- advance
-		c_sigd = c_rseg.next
+		c_sigd = nvar
 		i = i + 1
 	end
 	if c_sigd then
 		local e_tcbs = ildb.get_tcbs(c_sigd)
-		itab("Konec cesty: "..sigd_to_string(c_sigd).." ("..(e_tcbs and e_tcbs.signal_name or "-")..")")
+		local signame = "-"
+		if e_tcbs and e_tcbs.signal then signame = e_tcbs.signal_name or "o" end
+		itab(i, "E "..sigd_to_string(c_sigd).." ("..signame..")", "end", c_sigd)
 	else
-		itab("Cesta je slepá")
+		itab(i, "E (none)", "end", nil)
 	end
 	
-	form = form.."textlist[0.5,2;7.75,3.9;rtelog;"..table.concat(tab, ",").."]"
+	if not sel_rpartidx then sel_rpartidx = 1 end
+	form = form.."textlist[0.5,2;3.5,3.9;routelog;"..table.concat(tab, ",")..";"..(sel_rpartidx or 1)..";false]"
 	
-	form = form.."button[0.5,6;3,1;back;<<< Zpět na signalizaci]"
-	form = form.."button[4.5,6;2,1;aspect;Signál...]"
-	form = form.."button[6.5,6;2,1;delete;Smazat cestu]"
+	-- to the right of rtelog, controls are displayed for the thing in focus
+	-- What is in focus is determined by the parameter sel_rpartidx
+	
+	local sel_rpart = tabref[sel_rpartidx]
+	--atdebug("sel rpart",sel_rpart)
+	
+	if sel_rpart and sel_rpart.signal then
+		-- get TCBS here and rseg selected
+		local s_tcbs = ildb.get_tcbs(sel_rpart.param)
+		local rseg = route[sel_rpart.seg]
+		-- main aspect list
+		local signalpos = s_tcbs and s_tcbs.signal
+		if signalpos and rseg then
+			form = form..F.label(4.5, 2, "Signal Aspect:")
+			local ndef = signalpos and advtrains.ndb.get_ndef(signalpos)
+			if ndef and ndef.advtrains and ndef.advtrains.main_aspects then
+				local entries = { "<Default Aspect>" }
+				local sel = 1
+				for i, mae in ipairs(ndef.advtrains.main_aspects) do
+					entries[i+1] = mae.description
+					if mae.name == rseg.main_aspect then
+						sel = i+1
+					end
+				end
+				form = form..F.dropdown(4.5, 3.0, 4, "sa_main_aspect", entries, sel, true)
+			end
+			-- checkbox for assign distant signal
+			local assign_dst = rseg.assign_dst
+			if assign_dst == nil then
+				assign_dst = (sel_rpart.seg~=1) -- special behavior when assign_dst is nil (and not false):
+				-- defaults to false for the very first signal and true for all others (= minimal user configuration overhead)
+				-- Note: on save, the value will be fixed at either false or true
+			end
+			form = form..string.format("checkbox[4.5,4.0;sa_distant;Announce distant signal;%s]", assign_dst)
+		else
+			form = form..F.label(4.5, 2, "No Signal at this TCB")
+		end
+	elseif sel_rpart and sel_rpart.section then
+		local rseg = route[sel_rpart.seg]
+		if rseg then
+			form = form..F.label(4.5, 2, "Section Options:")
+			-- checkbox for call-on
+			form = form..string.format("checkbox[4.5,4.0;se_callon;Call-on (section may be occupied);%s]", rseg.call_on)
+		end
+	elseif sel_rpart and sel_rpart.err then
+		form = form.."textarea[4.5,2.5;4,4;errorta;Error:;"..tab[sel_rpartidx].."]"
+	else
+		form = form..F.label(4.5, 2, "<< Select a route part to edit options")
+	end
+	
+	form = form.."button[0.5,6;1,1;prev;<<<]"
+	form = form.."button[1.5,6;1,1;back;"..routeid.."/"..#tcbs.routes.."]"
+	form = form.."button[2.5,6;1,1;next;>>>]"
+	
+	
+	--if route.smartroute_generated or route.default_autoworking then
+	--	form = form.."button[3.5,6;2,1;noautogen;Clr Autogen]"
+	--end
+	form = form.."button[5.5,6;3,1;delete;Delete Route]"
+	form = form.."button[0.5,7;3,1;back;Back to signal]"
+	form = form.."button[3.5,7;2,1;clone;Clone Route]"
+	form = form.."button[5.5,7;3,1;newfrom;New From Route]"
 	
 	--atdebug(route.ars)
 	form = form.."style[ars;font=mono]"
-	form = form.."textarea[0.8,7.3;5,3;ars;Pravidla ARS;"..atil.ars_to_text(route.ars).."]"
-	form = form.."button[5.5,7.23;3,1;savears;Uložit pravidla ARS]"
+	form = form.."textarea[0.8,8.3;5,3;ars;ARS Rule List;"..atil.ars_to_text(route.ars).."]"
+	form = form.."button[5.5,8.23;3,1;savears;Save ARS List]"
 	
-	minetest.show_formspec(pname, "at_il_routeedit_"..minetest.pos_to_string(sigd.p).."_"..sigd.s.."_"..routeid, form)
-
+	local formname = "at_il_routeedit_"..minetest.pos_to_string(sigd.p).."_"..sigd.s.."_"..routeid
+	minetest.show_formspec(pname, formname, form)
+	-- record selected entry from routelog for receive fields callback
+	sel_rpartcache[pname] = sel_rpart
 end
 
 
 minetest.register_on_player_receive_fields(function(player, formname, fields)
 	local pname = player:get_player_name()
+	-- retreive sel_rpart from the cache in any case and clear it out
+	local sel_rpart = sel_rpartcache[pname]
 	if not minetest.check_player_privs(pname, {train_operator=true, interlocking=true}) then
 		return
 	end
@@ -118,26 +199,90 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		local route = tcbs.routes[routeid]
 		if not route then return end
 		
+		if fields.prev then
+			atil.show_route_edit_form(pname, sigd, routeid - 1)
+			return
+		end
+		if fields.next then
+			atil.show_route_edit_form(pname, sigd, routeid + 1)
+			return
+		end
+		
 		if fields.setname and fields.name then
 			route.name = fields.name
 		end
 		
-		if fields.aspect then
-			local suppasp = advtrains.interlocking.signal_get_supported_aspects(tcbs.signal)
-			
-			local callback = function(pname, asp)
-				route.aspect = asp
-				advtrains.interlocking.show_route_edit_form(pname, sigd, routeid)
+		if fields.sa_main_aspect and sel_rpart and sel_rpart.signal then
+			local idx = tonumber(fields.sa_main_aspect)
+			-- get TCBS here and rseg selected
+			local s_tcbs = ildb.get_tcbs(sel_rpart.param)
+			local rseg = route[sel_rpart.seg]
+			-- main aspect list
+			local signalpos = s_tcbs and s_tcbs.signal
+			if rseg then
+				rseg.main_aspect = nil
+				if idx > 1 then
+					local ndef = signalpos and advtrains.ndb.get_ndef(signalpos)
+					if ndef and ndef.advtrains and ndef.advtrains.main_aspects then
+						rseg.main_aspect = ndef.advtrains.main_aspects[idx - 1].name
+					end
+				end
 			end
-			
-			advtrains.interlocking.show_signal_aspect_selector(pname, suppasp, route.name, callback, route.aspect or advtrains.interlocking.GENERIC_FREE)
-			return
 		end
+		if fields.sa_distant and sel_rpart and sel_rpart.signal then
+			local rseg = route[sel_rpart.seg]
+			if rseg then
+				rseg.assign_dst = minetest.is_yes(fields.sa_distant)
+			end
+		end
+		if fields.se_callon and sel_rpart and sel_rpart.section then
+			local rseg = route[sel_rpart.seg]
+			if rseg then
+				rseg.call_on = minetest.is_yes(fields.se_callon)
+				-- reshow form to update CO marker
+				atil.show_route_edit_form(pname, sigd, routeid, sel_rpart.idx)
+				return
+			end
+		end
+		
+		--if fields.noautogen then
+		--	route.smartroute_generated = nil
+		--	route.default_autoworking = nil
+		--	-- reshow form for the button to disappear
+		--	atil.show_route_edit_form(pname, sigd, routeid, sel_rpart and sel_rpart.idx)
+		--	return
+		--end
+		
 		if fields.delete then
 			-- if something set the route in the meantime, make sure this doesn't break.
 			atil.route.update_route(sigd, tcbs, nil, true)
 			table.remove(tcbs.routes, routeid)
 			advtrains.interlocking.show_signalling_form(sigd, pname)
+			-- cleanup
+			sel_rpartcache[pname] = nil
+			return
+		end
+		
+		if fields.clone then
+			-- if something set the route in the meantime, make sure this doesn't break.
+			atil.route.update_route(sigd, tcbs, nil, true)
+			local rcopy = table.copy(route)
+			rcopy.name = route.name.."_copy"
+			rcopy.smartroute_generated = nil
+			table.insert(tcbs.routes, routeid+1, rcopy)
+			advtrains.interlocking.show_signalling_form(sigd, pname)
+			-- cleanup
+			sel_rpartcache[pname] = nil
+			return
+		end
+
+		if fields.newfrom then
+			advtrains.interlocking.init_route_prog(pname, sigd, route)
+			minetest.close_formspec(pname, formname)
+			tcbs.ars_ignore_next = nil
+			-- cleanup
+			sel_rpartcache[pname] = nil
+			return
 		end
 		
 		if fields.ars and fields.savears then
@@ -147,6 +292,25 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		
 		if fields.back then
 			advtrains.interlocking.show_signalling_form(sigd, pname)
+			-- cleanup
+			sel_rpartcache[pname] = nil
+			return
+		end
+		
+		-- if an entry was selected in the textlist (and its not the current one) update the form
+		if fields.routelog then
+			local prev_idx = sel_rpart and sel_rpart.idx or 1
+			local tev = minetest.explode_textlist_event(fields.routelog)
+			local new_idx = tev and tev.index
+			if new_idx and new_idx ~= prev_idx then
+				atil.show_route_edit_form(pname, sigd, routeid, new_idx)
+				return
+			end
+		end
+		
+		if fields.quit then
+			-- cleanup
+			sel_rpartcache[pname] = nil
 		end
 		
 	end
diff --git a/advtrains_interlocking/routesetting.lua b/advtrains_interlocking/routesetting.lua
index 67efaea..6544a92 100644
--- a/advtrains_interlocking/routesetting.lua
+++ b/advtrains_interlocking/routesetting.lua
@@ -43,13 +43,19 @@ function ilrs.set_route(signal, route, try)
 	local first = true
 	local i = 1
 	local rtename = route.name
-	local signalname = ildb.get_tcbs(signal).signal_name
+	local signalname = (ildb.get_tcbs(signal).signal_name or "") .. sigd_to_string(signal)
 	local c_tcbs, c_ts_id, c_ts, c_rseg, c_lckp
+	-- signals = { { pos = ., tcbs_ref = <tcbs>, role = "main_distant", main_aspect = nil, dst_type = "next_main" or "none" } 
+	local signals = {}
+	local nodst
 	while c_sigd and i<=#route do
 		c_tcbs = ildb.get_tcbs(c_sigd)
 		if not c_tcbs then
 			if not try then atwarn("Did not find TCBS",c_sigd,"while setting route",rtename,"of",signal) end
-			return false, "No TCB found at "..sigd_to_string(c_sigd)..". Please reconfigure route!"
+			return false, "No TCB found at "..sigd_to_string(c_sigd)..". Please update or reconfigure route!"
+		end
+		if i == 1 then
+			nodst = c_tcbs.nodst
 		end
 		c_ts_id = c_tcbs.ts_id
 		if not c_ts_id then
@@ -60,42 +66,79 @@ function ilrs.set_route(signal, route, try)
 		c_rseg = route[i]
 		c_lckp = {}
 		
-		if c_ts.route then
+		if not c_ts then
+			if not try then atwarn("Encountered ts missing during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end
+			return false, "Section '"..(c_ts_id).."' not found!", c_ts_id, nil
+		elseif c_ts.route then
 			if not try then atwarn("Encountered ts lock during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end
-			return false, "Section '"..c_ts.name.."' already has route set from "..sigd_to_string(c_ts.route.origin)..":\n"..c_ts.route.rsn, c_ts_id, nil
+			return false, "Section '"..(c_ts.name or c_ts_id).."' already has route set from "..sigd_to_string(c_ts.route.origin)..":\n"..c_ts.route.rsn, c_ts_id, nil
 		end
 		if c_ts.trains and #c_ts.trains>0 then
-			if not try then atwarn("Encountered ts occupied during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end
-			return false, "Section '"..c_ts.name.."' is occupied!", c_ts_id, nil
+			if c_rseg.call_on then
+				--atdebug("Routesetting: Call-on situation in", c_ts_id)
+			else
+				if not try then atwarn("Encountered ts occupied during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end
+				return false, "Section '"..(c_ts.name or c_ts_id).."' is occupied!", c_ts_id, nil
+			end
 		end
 		
-		for pts, state in pairs(c_rseg.locks) do
-			local confl = ilrs.has_route_lock(pts, state)
+		-- collect locks from rs cache and from route def
+		local c_locks = {}
+		if route.use_rscache and c_ts.rs_cache and c_rseg.next then
+			-- rscache needs to be enabled, present and next must be defined
+			start_pkey = advtrains.encode_pos(c_sigd.p)
+			end_pkey = advtrains.encode_pos(c_rseg.next.p)
+			if c_ts.rs_cache[start_pkey] and c_ts.rs_cache[start_pkey][end_pkey] then
+				for lp,lst in pairs(c_ts.rs_cache[start_pkey][end_pkey]) do
+					--atdebug("Add lock from RSCache:",lp,"->",lst)
+					c_locks[lp] = lst
+				end
+			elseif not try then
+				atwarn("While setting route",rtename,"of",signal,"segment "..i..",required path from",c_tcbs,"to",c_rseg.next,"was not found in the track section's RS cache. Please check!")
+			end
+		end
+		-- add all from locks, these override the rscache
+		for lpts,lst in pairs(c_rseg.locks) do
+			--atdebug("Add lock from Routedef:",lpts,"->",lst,"overrides",c_locks[lpts] or "none")
+			c_locks[lpts] = lst
+		end
+		
+		for lp, state in pairs(c_locks) do
+			local confl = ilrs.has_route_lock(lp, state)
 			
-			local pos = minetest.string_to_pos(pts)
+			local pos = advtrains.decode_pos(lp)
 			if advtrains.is_passive(pos) then
 				local cstate = advtrains.getstate(pos)
 				if cstate ~= state then
-					local confl = ilrs.has_route_lock(pts)
+					local confl = ilrs.has_route_lock(lp)
 					if confl then
-						if not try then atwarn("Encountered route lock while a real run of routesetting routine, at position",pts,"while setting route",rtename,"of",signal) end
-						return false, "Lock conflict at "..pts..", Held locked by:\n"..confl, nil, pts
+						if not try then atwarn("Encountered route lock while a real run of routesetting routine, at position",pos,"while setting route",rtename,"of",signal) end
+						return false, "Lock conflict at "..minetest.pos_to_string(pos)..", Held locked by:\n"..confl, nil, lp
 					elseif not try then
 						advtrains.setstate(pos, state)
 					end
 				end
 				if not try then
-					ilrs.add_route_lock(pts, c_ts_id, "Route '"..rtename.."' from signal '"..signalname.."'", signal)
-					c_lckp[#c_lckp+1] = pts
+					ilrs.add_route_lock(lp, c_ts_id, "Route '"..rtename.."' from signal '"..signalname.."'", signal)
+					c_lckp[#c_lckp+1] = lp
 				end
 			else
 				if not try then atwarn("Encountered route lock misconfiguration (no passive component) while a real run of routesetting routine, at position",pts,"while setting route",rtename,"of",signal) end
-				return false, "No passive component at "..pts..". Please reconfigure route!"
+				return false, "No passive component at "..minetest.pos_to_string(pos)..". Please update track section or reconfigure route!"
+			end
+		end
+		-- sanity check, is section at next the same as the current?
+		local nvar = c_rseg.next
+		if nvar then
+			local re_tcbs = ildb.get_tcbs({p = nvar.p, s = (nvar.s==1) and 2 or 1})
+			if (not re_tcbs or not re_tcbs.ts_id or re_tcbs.ts_id~=c_ts_id)
+					and route[i+1] then --FIX 2025-01-08: in old worlds the final TCB may be wrong (it didn't matter back then), don't error out here (route still shown invalid in UI)
+				if not try then atwarn("Encountered inconsistent ts (front~=back) while a real run of routesetting routine, at position",pts,"while setting route",rtename,"of",signal) end
+				return false, "TCB at "..minetest.pos_to_string(nvar.p).." has different section than previous TCB. Please update track section or reconfigure route!"
 			end
 		end
 		-- reserve ts and write locks
 		if not try then
-			local nvar = c_rseg.next
 			if not route[i+1] then
 				-- We shouldn't use the "next" value of the final route segment, because this can lead to accidental route-cancelling of already set routes from another signal.
 				nvar = nil
@@ -112,9 +155,22 @@ function ilrs.set_route(signal, route, try)
 			}
 			if c_tcbs.signal then
 				c_tcbs.route_committed = true
-				c_tcbs.aspect = route.aspect or advtrains.interlocking.GENERIC_FREE
 				c_tcbs.route_origin = signal
-				advtrains.interlocking.update_signal_aspect(c_tcbs)
+				-- determine route role
+				local ndef = advtrains.ndb.get_ndef(c_tcbs.signal)
+				local assign_dst = c_rseg.assign_dst
+				if assign_dst == nil then
+					assign_dst = (i~=1) -- special behavior when assign_dst is nil (and not false):
+					-- defaults to false for the very first signal and true for all others (= minimal user configuration overhead)
+				end
+				local sig_table = {
+					pos = c_tcbs.signal,
+					tcbs_ref = c_tcbs,
+					role = ndef and ndef.advtrains and ndef.advtrains.route_role,
+					main_aspect = c_rseg.main_aspect,
+					assign_dst = assign_dst
+				}
+				signals[#signals+1] = sig_table
 			end
 		end
 		-- advance
@@ -122,10 +178,47 @@ function ilrs.set_route(signal, route, try)
 		c_sigd = c_rseg.next
 		i = i + 1
 	end
+
+	-- Get reference to signal at end of route
+	local last_mainsig = nil
+	if c_sigd then
+		local e_tcbs = ildb.get_tcbs(c_sigd)
+		local pos = e_tcbs and e_tcbs.signal
+		if pos then
+			last_mainsig = pos
+		end
+	end
+	for i = #signals, 1, -1 do
+		-- note the signals are iterated backwards. Switch depending on the role
+		local sig = signals[i]
+		-- apply mainaspect
+		sig.tcbs_ref.route_aspect = sig.main_aspect or "_default" -- or route.main_aspect : TODO this does not work if a distant signal is on the path! Implement per-sig aspects!
+		if sig.role == "distant" or sig.role == "distant_repeater" or sig.role == "main_distant" then
+			if last_mainsig then
+				-- assign the remote as the last mainsig if desired
+				if sig.assign_dst then
+					sig.tcbs_ref.route_remote = last_mainsig
+				end
+				-- if it wasn't a distant_repeater clear the mainsig
+				if sig.role ~= "distant_repeater" then
+					last_mainsig = false
+				end
+			end
+		end
+		if sig.role == "main" or sig.role == "main_distant" or sig.role == "end" then
+			-- record this as the new last mainsig
+			last_mainsig = sig.pos
+		end
+		-- for shunt signals nothing happens
+		-- update the signal aspect on map
+		advtrains.interlocking.signal.update_route_aspect(sig.tcbs_ref, i ~= 1)
+	end
 	
 	return true
 end
 
+-- Change 2024-01-27: pts is not an encoded pos, not a pos-to-string!
+
 -- Checks whether there is a route lock that prohibits setting the component
 -- to the wanted state. returns string with reasons on conflict
 function ilrs.has_route_lock(pts)
@@ -172,6 +265,11 @@ function ilrs.free_route_locks(ts, lcks, nocallbacks)
 end
 
 function ilrs.free_route_locks_indiv(pts, ts, nocallbacks)
+	-- legacy: if starts with bracket then pts is still in old pos_to_string format (may happen because ts.route_post is not migrated)
+	if string.match(pts, "^%(") then
+		atdebug("free_route_locks_indiv: converting position",pts)
+		pts = advtrains.encode_pos(minetest.string_to_pos(pts))
+	end
 	local e = ilrs.rte_locks[pts]
 	if not e then return nil
 	elseif #e==0 then
@@ -191,7 +289,7 @@ function ilrs.free_route_locks_indiv(pts, ts, nocallbacks)
 	-- TODO use luaautomation timers?
 	if not nocallbacks then
 		minetest.after(0, ilrs.update_waiting, "lck", pts)
-		minetest.after(0.5, advtrains.set_fallback_state, minetest.string_to_pos(pts))
+		minetest.after(0.5, advtrains.set_fallback_state, advtrains.decode_pos(pts))
 	end
 end
 -- frees all route locks, even manual ones set with the tool, at a specific position
@@ -224,12 +322,13 @@ function ilrs.cancel_route_from(sigd)
 		--atdebug("cancelling",c_ts.route.rsn)
 		-- clear signal aspect and routesetting state
 		c_tcbs.route_committed = nil
-		c_tcbs.aspect = nil
+		c_tcbs.route_aspect = nil
+		c_tcbs.route_remote = nil
 		c_tcbs.routeset = nil
 		c_tcbs.route_auto = nil
 		c_tcbs.route_origin = nil
 		
-		advtrains.interlocking.update_signal_aspect(c_tcbs)
+		advtrains.interlocking.signal.update_route_aspect(c_tcbs)
 		
 		c_ts_id = c_tcbs.ts_id
 		if not c_tcbs then
@@ -273,17 +372,19 @@ function ilrs.update_route(sigd, tcbs, newrte, cancel)
 		--atdebug("Signal not in control, held by",tcbs.signal_name)
 		return
 	end
+	-- clear route_rsn, it will be set again if needed
+	tcbs.route_rsn = nil
 	if (newrte and tcbs.routeset and tcbs.routeset ~= newrte) or cancel then
 		if tcbs.route_committed then
 			--atdebug("Cancelling:",tcbs.routeset)
 			advtrains.interlocking.route.cancel_route_from(sigd)
 		end
 		tcbs.route_committed = nil
-		tcbs.aspect = nil
+		tcbs.route_aspect = nil
+		tcbs.route_remote = nil
 		has_changed_aspect = true
 		tcbs.routeset = nil
 		tcbs.route_auto = nil
-		tcbs.route_rsn = nil
 	end
 	if newrte or tcbs.routeset then
 		if tcbs.route_committed then
@@ -291,7 +392,14 @@ function ilrs.update_route(sigd, tcbs, newrte, cancel)
 		end
 		if newrte then tcbs.routeset = newrte end
 		--atdebug("Setting:",tcbs.routeset)
-		local succ, rsn, cbts, cblk = ilrs.set_route(sigd, tcbs.routes[tcbs.routeset])
+		local succ, rsn, cbts, cblk
+		local route = tcbs.routes[tcbs.routeset]
+		if route then
+			succ, rsn, cbts, cblk = ilrs.set_route(sigd, route)
+		else
+			succ = false
+			rsn = attrans("Route state changed.")
+		end
 		if not succ then
 			tcbs.route_rsn = rsn
 			--atdebug("Routesetting failed:",rsn)
@@ -308,12 +416,17 @@ function ilrs.update_route(sigd, tcbs, newrte, cancel)
 			end
 		else
 			--atdebug("Committed Route:",tcbs.routeset)
-			has_changed_aspect = true
+			-- set_route now sets the signal aspects
+			--has_changed_aspect = true
+			-- route success. apply default_autoworking flag if requested
+			if route.default_autoworking then
+				tcbs.route_auto = true --FIX 2025-01-08: never set it to false if it was true!
+			end
 		end
 	end
 	if has_changed_aspect then
 		-- FIX: prevent an minetest.after() loop caused by update_signal_aspect dispatching path invalidation, which in turn calls ARS again
-		advtrains.interlocking.update_signal_aspect(tcbs)
+		advtrains.interlocking.signal.update_route_aspect(tcbs)
 	end
 	advtrains.interlocking.update_player_forms(sigd)
 end
diff --git a/advtrains_interlocking/signal_api.lua b/advtrains_interlocking/signal_api.lua
index 15f26ca..7d718a4 100644
--- a/advtrains_interlocking/signal_api.lua
+++ b/advtrains_interlocking/signal_api.lua
@@ -1,539 +1,479 @@
 -- Signal API implementation
 
+local F = advtrains.formspec
 
---[[
-Signal aspect table:
-Note: All speeds are measured in m/s, aka the number of + signs in the HUD.
-asp = {
-	main = <int speed>,
-		-- Main signal aspect, tells state and permitted speed of next section
-		-- 0 = section is blocked
-		-- >0 = section is free, speed limit is this value
-		-- -1 = section is free, maximum speed permitted
-		-- false/nil = Signal doesn't provide main signal information, retain current speed limit.
-	shunt = <boolean>,
-		-- Whether train may proceed as shunt move, on sight
-		-- main aspect takes precedence over this
-		-- When main==0, train switches to shunt move and is restricted to speed 6
-	proceed_as_main = <boolean>,
-		-- If an approaching train is a shunt move and 'shunt' is false,
-		-- the train may proceed as a train move under the "main" aspect
-		-- if the main aspect permits it (i.e. main!=0)
-		-- If this is not set, shunt moves are NOT allowed to switch to
-		-- a train move, and must stop even if "main" would permit passing.
-		-- This is intended to be used for "Halt for shunt moves" signs.
-	
-	dst = <int speed>,
-		-- Distant signal aspect, tells state and permitted speed of the section after next section
-		-- The character of these information is purely informational
-		-- At this time, this field is not actively used
-		-- 0 = section is blocked
-		-- >0 = section is free, speed limit is this value
-		-- -1 = section is free, maximum speed permitted
-		-- false/nil = Signal doesn't provide distant signal information.
-	
-	-- the character of call_on and dead_end is purely informative
-	call_on = <boolean>, -- Call-on route, expect train in track ahead (not implemented yet)
-	dead_end = <boolean>, -- Route ends on a dead end (e.g. bumper) (not implemented yet)
-
-	w_speed = <integer>,
-	-- "Warning speed restriction". Supposed for short-term speed
-	-- restrictions which always override any other restrictions
-	-- imposed by "speed" fields, until lifted by a value of -1
-	-- (Example: german Langsamfahrstellen-Signale)
-	}
-}
-
-== How signals actually work in here ==
-Each signal (in the advtrains universe) is some node that has at least the
-following things:
-- An "influence point" that is set somewhere on a rail
-- An aspect which trains that pass the "influence point" have to obey
+local signal = {}
 
-There can be static and dynamic signals. Static signals are, roughly
-spoken, signs, while dynamic signals are "real" signals which can display
-different things.
-
-The node definition of a signal node should contain those fields:
-groups = {
-  	advtrains_signal = 2,
-	save_in_at_nodedb = 1,
+signal.MASP_HALT = {
+	name = "_halt",
+	halt = true,
 }
-advtrains = {
-	set_aspect = function(pos, node, asp)
-		-- This function gets called whenever the signal should display
-		-- a new or changed signal aspect. It is not required that
-		-- the signal actually displays the exact same aspect, since
-		-- some signals can not do this by design. However, it must
-		-- display an aspect that is at least as restrictive as the passed
-		-- aspect as far as it is capable of doing so.
-		-- Examples:
-		-- - pure shunt signals can not display a "main" aspect
-		--   and have no effect on train moves, so they will only ever
-		--   honor the shunt.free field for their aspect.
-		-- - the german Hl system can only signal speeds of 40, 60
-		--   and 100 km/h, a speed of 80km/h should then be signalled
-		--   as 60 km/h instead.
-		-- In turn, it is not guaranteed that the aspect will fulfill the
-		-- criteria put down in supported_aspects.
-		-- If set_aspect is present, supported_aspects should also be declared.
-		
-		-- The aspect passed in here can always be queried using the
-		-- advtrains.interlocking.signal_get_supposed_aspect(pos) function.
-		-- It is always DANGER when the signal is not used as route signal.
-		
-		-- For static signals, this function should be completely omitted
-		-- If this function is omitted, it won't be possible to use
-		-- route setting on this signal.
-	end,
-	supported_aspects = {
-		-- A table which tells which different types of aspects this signal
-		--  is able to display. It is used to construct the "aspect editing"
-		--  formspec for route programming (and others) It should always be
-		--  present alongside with set_aspect. If this is not specified but
-		--  set_aspect is, the user will be allowed to select any aspect.
-		-- Any of the fields marked with <boolean/nil> support 3 types of values:
-				nil: if this signal can switch between free/blocked
-				false: always shows "blocked", unchangable
-				true: always shows "free", unchangable
-		-- Any of the "speed" fields should contain a list of possible values
-		--  to be set as restriction. If omitted, the value of the described
-		--  field is always assumed to be false (no information)
-		-- A speed of 0 means that the signal can show a "blocked" aspect
-		--  (which is probably the case for most signals)
-		-- If the signal can signal "no information" on one of the fields
-		--  (thus false is an acceptable value), include false in the list
-		-- If your signal can only display a single speed (may it be -1),
-		--  always enclose that single value into a list. (such as {-1})
-		main = {<speed1>, ..., <speedn>} or nil,
-		dst = {<speed1>, ..., <speedn>} or nil,
-		shunt = <boolean/nil>,
-		
-		call_on = <boolean/nil>,
-		dead_end = <boolean/nil>,
-		w_speed = {<speed1>, ..., <speedn>} or nil,
-		
-	},
-	Example for supported_aspects:
-	supported_aspects = {
-		main = {0, 6, -1}, -- can show either "Section blocked", "Proceed at speed 6" or "Proceed at maximum speed"
-		dst = {0, false}, -- can show only if next signal shows "blocked", no other information.
-		shunt = false, -- shunting by this signal is never allowed.
-		
-		call_on = false,
-		dead_end = false,
-		w_speed = nil,
-		-- none of the information can be shown by the signal
-		
-	},
-	
-	get_aspect = function(pos, node)
-		-- This function gets called by the train safety system. It
-		should return the aspect that this signal actually displays,
-		not preferably the input of set_aspect.
-		-- For regular, full-featured light signals, they will probably
-		honor all entries in the original aspect, however, e.g.
-		simple shunt signals always return main=false regardless of
-		the set_aspect input because they can not signal "Halt" to
-		train moves.
-		-- advtrains.interlocking.DANGER contains a default "all-danger" aspect.
-		-- If your signal does not cover certain sub-tables of the aspect,
-		the following reasonable defaults are automatically assumed:
-		main = false (unchanged)
-		dst = false (unchanged)
-		shunt = false (shunting not allowed)
-		info = {} (no further information)
-	end,
+
+signal.MASP_DEFAULT = {
+	name = "_default",
+	default = true,
 }
-on_rightclick = advtrains.interlocking.signal_rc_handler
-can_dig =  advtrains.interlocking.signal_can_dig
-after_dig_node = advtrains.interlocking.signal_after_dig
-
-(If you need to specify custom can_dig or after_dig_node callbacks,
-please call those functions anyway!)
-
-Important note: If your signal should support external ways to set its
-aspect (e.g. via mesecons), there are some things that need to be considered:
-- advtrains.interlocking.signal_get_supposed_aspect(pos) won't respect this
-- Whenever you change the signal aspect, and that aspect change
-did not happen through a call to
-advtrains.interlocking.signal_set_aspect(pos, asp), you are
-*required* to call this function:
-advtrains.interlocking.signal_on_aspect_changed(pos)
-in order to notify trains about the aspect change.
-This function will query get_aspect to retrieve the new aspect.
-
-]]--
-
-local DANGER = {
+
+signal.ASPI_HALT = {
 	main = 0,
-	dst = false,
 	shunt = false,
 }
-advtrains.interlocking.DANGER = DANGER
 
-advtrains.interlocking.GENERIC_FREE = {
+signal.ASPI_FREE = {
 	main = -1,
 	shunt = false,
-	dst = false,
+	proceed_as_main = true,
 }
 
-local function convert_aspect_if_necessary(asp)
-	if type(asp.main) == "table" then
-		local newasp = {} 
-		if asp.main.free then
-			newasp.main = asp.main.speed
-		else
-			newasp.main = 0
-		end
-		if asp.dst and asp.dst.free then
-			newasp.dst = asp.dst.speed
-		else
-			newasp.dst = 0
+--[[
+Implementation plan orwell 2024-01-28:
+Most parts of ywang's implementation are fine, especially I like the formspecs. But I would like to change a few aspects (no pun intended) of this.
+- Signal gets distant assigned via field in signal aspect table (instead of explicitly)
+- Signal speed/shunt are no longer free-text but rather they need to be predefined in the node definition
+To do this: Differentiation between:
+== Main Aspect ==
+This is what a signal is assigned by either the route system or the user.
+It is a string key which has an appropriate entry in the node definition (where it has a description assigned)
+The signal mod defines a function to set a signal to the most appropriate aspect. This function gets
+a) the main aspect table (straight from node def)
+b) the distant signal's aspect group name & aspect table
+
+== Aspect ==
+One concrete combination of lights/shapes that a signal signal shows. Handling these is at the discretion of
+the signal mod defining the signal, and they are typically combinations of main aspect and distant aspect
+Example:
+- A Ks signal has the main_aspect="proceed_12" set for a route
+- The signal at the end of the route shows main_aspect="proceed_8", advtrains also passes on that this means {main=8, shunt=false}
+- The ndef.afunction(pos, node, main_aspect, rem_aspect, rem_aspinfo) determines that the signal should now show
+		blinking green with main indicator 12 and dst indicator 8, and sets the nodes accordingly.
+		This function can now return the Aspect Info table, which will be cached by advtrains until the aspect changes again
+		and will be used when a train approaches the signal. If nil is returned, then the aspect will be queried next time
+		by calling ndef.advtrains.get_aspect_info(pos)
+
+Note that once apply_aspect returns, there is no need for advtrains anymore to query the aspect info.
+When the signal, for any reason, wants to change its aspect by itself *without* going through the signal API then
+it should update the aspect info cache by calling advtrains.interlocking.signal.update_aspect_info(pos)
+
+Apply_aspect may also receive the special main aspect { name = "_halt", halt = true }. It usually means that the signal is not assigned to anything particular,
+and it should cause the signal to show its most restrictive aspect. Typically it is a halt aspect, but e.g. for distant-only
+signals this would be "expect stop".
+
+A special case occurs for pure distant signals: Such signals must set apply_aspect, but must not set main_aspects. Behavior is as follows:
+- Signal is uninitialized, distant signal is not assigned to a main signal, or no route is set: main_aspect == { name = "_halt", halt = true } and rem_aspect == nil
+- A remote main signal is assigned (either by user or by route): main_aspect is always { name = "_default" } and rem_aspect / rem_aspinfo give the correct information
+
+Main aspect names starting with underscore (e.g. "_default") are reserved and must not be used!
+
+== Aspect Info ==
+The actual signal aspect in the already-known format. This is what the trains use to determine halt/proceed and speed.
+asp = {
+	main = 0 (halt) / -1 (max speed) / false (no info) / <number> (speed limit)
+	shunt = true (shunt free) / false (shunt not free)
+	proceed_as_main = true (shunt move can proceed and become train move when main!=0) / false (no)
+	dst = speed of the remote signal (like main, informative character, not actually used)
+}
+
+Node definition of signals:
+- The signal needs some logic to figure out, for each combination of its own aspect group and the distant signal's aspect, what aspect info it can/will show.
+ndef.advtrains = {
+	main_aspects = {
+		{ name = "proceed" description = "Proceed at full speed", <more data at discretion of signal>}
+		{ name = "reduced" description = "Proceed at reduced speed", <more data at discretion of signal>}
+	}
+		-- This list is mainly for the selection dialog. Order of entries determines list order in the dropdown.
+		-- Some fields have special meaning:
+		-- name: A unique key to identify the main aspect. Might be required by some code.
+		-- description: Text shown in UI dropdown
+		-- Node can set any other fields at its discretion. They are not touched.
+		-- Note: Pure distant signals should set one main aspect, and set the "pure_distant = true" field
+	apply_aspect = function(pos, node, main_aspect, rem_aspect, rem_aspinfo)
+		-- set the node to show the desired aspect
+		-- called by advtrains when this signal's aspect group or the remote signal's aspect changes
+		-- main_aspect is never nil, but can be the special aspect { name = "_halt", halt = true }
+		-- MAY return the aspect_info. If it returns nil then get_aspect_info will be queried at a later point.
+	get_aspect_info(pos, main_aspect)
+		-- Returns the aspect info table (main, shunt, dst etc.)
+	distant_support = true or false
+		-- If true, signal is considered in distant signalling. If false or nil, rem_aspect and rem_aspinfo are never set.
+	route_role = one of "main", "main_distant", "shunt", "distant", "distant_repeater", "end"
+		-- Determines how the signal behaves when routes are set. Only in effect when signal is assigned to a TCB.
+		-- main: The signal is a possible endpoint for a train move route. Distant signals before it refer to it.
+		-- shunt: The signal is a possible endpoint for a shunt move route. Ignored for distant signals.
+		-- distant, distant_repeater: The next signal with role="main" is set as the remote signal. main_aspects may be undefined, the main aspect passed to apply_aspect is a dummy one in this case.
+		-- distant: if more than one distant signal is before a main signal, only the last one is assigned (but any number of distant_repeater signals are allowed)
+		-- main_distant: Combination of main and distant - like "main", but additionally gets assigned to the next main like a "distant"
+		-- end: like main, but signifies that it marks an end of track and trains cannot continue further. (currently no practical implications above main)
+	pure_distant = true / false
+		-- If true, this signal is assumed to be a pure distant signal (its halt aspect is rather "expect halt" and it cannot show a true "stop here")
+		-- The following special behavior applies when this signal is assigned to a TCB: When a train passes the signal, the aspect is not reset to the
+		-- halt aspect and it continues to announce the remote signal's aspect (like in real life)
+		-- Typically such signals have one main aspect, their appearance depends almost exclusively on their remote signal and the halt aspect is the same as
+		-- the aspect shown when the main aspect is set but the remote signal is at halt.
+}
+
+== Nomenclature ==
+The distant/main relation is named as follows:
+     V    M
+=====>====>
+Main signal (main) always refers to the signal that is in focus right now (even if that is a distant-only signal)
+From the standpoint of M, V is the distant (dst) signal. M does not need to concern itself with V's aspect but needs to notify V when it changes
+From the standpoint of V, M is the remote (rem) signal. V needs to show an aspect that matches its remote signal M
+
+== Criteria for which signals are eligible for routes ==
+
+All signals must define:
+- get_aspect_info()
+
+Signals that can be assigned to a TCB must satisfy:
+- apply_aspect() defined
+
+Signals that are possible start and end points for a route must satisfy:
+- main_aspects defined (note, pure distant signals should therefore not define main_aspects)
+
+]]
+
+-- Database
+-- Signal Aspect store
+-- Stores for each signal the main aspect and other info, like the assigned remote signal
+-- [signal encodePos] = { main = <table or string>, [remote = encodedPos] }
+-- main is a string: "named aspect" is looked up in the main_aspects table of the ndef
+-- main is a table: this table directly is the main aspect (used for advanced signals with additional lights/indicators)
+signal.aspects = {}
+
+-- Distant signal notification. Records for each signal the distant signals that refer to it
+-- Note: this mapping is weak. Needs always backreference check.
+-- [signal encodePos] = { [distant signal encodePos] = true }
+signal.distant_refs = {}
+
+function signal.load(data)
+	signal.aspects = data.aspects or {}
+	-- rebuild distant_refs after load
+	signal.distant_refs = {}
+	for main, aspt in pairs(signal.aspects) do
+		if aspt.remote then
+			if not signal.distant_refs[aspt.remote] then
+				signal.distant_refs[aspt.remote] = {}
+			end
+			signal.distant_refs[aspt.remote][main] = true
 		end
-		newasp.proceed_as_main = asp.shunt.proceed_as_main
-		newasp.shunt = asp.shunt.free
-		-- Note: info table not transferred, it's not used right now
-		return newasp
 	end
-	return asp
 end
 
-function advtrains.interlocking.update_signal_aspect(tcbs)
-	if tcbs.signal then
-		local asp = tcbs.aspect or DANGER
-		advtrains.interlocking.signal_set_aspect(tcbs.signal, asp)
-	end
+function signal.save(data)
+	data.aspects = signal.aspects
 end
 
-function advtrains.interlocking.signal_can_dig(pos)
-	return not advtrains.interlocking.db.get_sigd_for_signal(pos)
-end
 
-function advtrains.interlocking.signal_after_dig(pos)
-	-- clear influence point
-	advtrains.interlocking.db.clear_ip_by_signalpos(pos)
+-- Set a signal's aspect.
+-- Signal aspects should only be set through this function. It takes care of:
+-- - Storing the main aspect and dst pos for this signal permanently (until next change)
+-- - Assigning the distant signal for this signal
+-- - Calling apply_aspect() in the signal's node definition to make the signal show the aspect
+-- - Calling apply_aspect() again whenever the remote signal changes its aspect
+-- - Notifying this signal's distant signals about changes to this signal (unless skip_dst_notify is specified)
+-- main_asp: either a string (==name in ndef.advtrains.main_aspects) or the main aspect table directly (for advanced signals)
+function signal.set_aspect(pos, main_asp, rem_pos, skip_dst_notify)
+	-- safeguard for the two integrated aspects (these two must be passed as string key)
+	if type(main_asp)=="table" and (main_asp.name=="_default" or main_asp.name=="_halt") then
+		error("MASP_HALT and MASP_DEFAULT must be passed via string keys _halt or _default, not as tables!")
+	end
+	local main_pts = advtrains.encode_pos(pos)
+	local old_tbl = signal.aspects[main_pts]
+	local old_remote = old_tbl and old_tbl.remote
+	local new_remote = rem_pos and advtrains.encode_pos(rem_pos)
+	
+	-- if remote has changed, unregister from old remote
+	if old_remote and old_remote~=new_remote and signal.distant_refs[old_remote] then
+		--atdebug("unregister old remote: ",old_remote,"from",main_pts)
+		signal.distant_refs[old_remote][main_pts] = nil
+	end
+		
+	signal.aspects[main_pts] = { main = main_asp, remote = new_remote }
+	-- apply aspect on main signal, this also checks new_remote
+	signal.reapply_aspect(main_pts)	
+	
+	-- notify my distants about this change (with limit 2)
+	if not skip_dst_notify then
+		signal.notify_distants_of(main_pts, 2)
+	end
 end
 
-function advtrains.interlocking.signal_set_aspect(pos, asp)
-	asp = convert_aspect_if_necessary(asp)
-	local node=advtrains.ndb.get_node(pos)
-	local ndef=minetest.registered_nodes[node.name]
-	if ndef and ndef.advtrains and ndef.advtrains.set_aspect then
-		ndef.advtrains.set_aspect(pos, node, asp)
-		advtrains.interlocking.signal_on_aspect_changed(pos)
+function signal.clear_aspect(pos, skip_dst_notify)
+	local main_pts = advtrains.encode_pos(pos)
+	local old_tbl = signal.aspects[main_pts]
+	local old_remote = old_tbl and old_tbl.remote
+	
+	-- unregister from old remote
+	if old_remote then
+		signal.distant_refs[old_remote][main_pts] = nil
+	end
+		
+	signal.aspects[main_pts] = nil
+	-- apply aspect on main signal, this also checks new_remote
+	signal.reapply_aspect(main_pts)	
+	
+	-- notify my distants about this change (with limit 2)
+	if not skip_dst_notify then
+		signal.notify_distants_of(main_pts, 2)
 	end
 end
 
--- should be called when aspect has changed on this signal.
-function advtrains.interlocking.signal_on_aspect_changed(pos)
-	local ipts, iconn = advtrains.interlocking.db.get_ip_by_signalpos(pos)
-	if not ipts then return end
-	local ipos = minetest.string_to_pos(ipts)
+-- Clear any info about aspects from this signal, without resetting/reapplying the aspect.
+-- Supposed to be used for legacy on-off signals when the on-off toggle is used
+function signal.unregister_aspect(pos)
+	local main_pts = advtrains.encode_pos(pos)
+	local old_tbl = signal.aspects[main_pts]
+	local old_remote = old_tbl and old_tbl.remote
 	
-	advtrains.invalidate_all_paths_ahead(ipos)
+	-- unregister from old remote
+	if old_remote then
+		signal.distant_refs[old_remote][main_pts] = nil
+	end
+		
+	signal.aspects[main_pts] = nil
 end
 
-function advtrains.interlocking.signal_rc_handler(pos, node, player, itemstack, pointed_thing)
-	local pname = player:get_player_name()
-	local control = player:get_player_control()
-	if control.aux1 then
-		advtrains.interlocking.show_ip_form(pos, pname)
+-- Notify distant signals of main_pts of a change in the aspect of this signal
+-- 
+function signal.notify_distants_of(main_pts, limit)
+	--atdebug("notify_distants_of",advtrains.decode_pos(main_pts),"limit",limit)
+	if limit <= 0 then
 		return
 	end
-	
-	local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
-	if sigd then
-		advtrains.interlocking.show_signalling_form(sigd, pname)
-	else
-		local ndef = minetest.registered_nodes[node.name]
-		if ndef.advtrains and ndef.advtrains.set_aspect then
-			-- permit to set aspect manually
-			local function callback(pname, aspect)
-				advtrains.interlocking.signal_set_aspect(pos, aspect)
+	local dstrefs = signal.distant_refs[main_pts]
+	--atdebug("dstrefs",dstrefs,"")
+	if dstrefs then
+		for dst,_ in pairs(dstrefs) do
+			-- ensure that the backref is still valid
+			local dst_asp = signal.aspects[dst]
+			if dst_asp and dst_asp.remote == main_pts then
+				signal.reapply_aspect(dst)
+				signal.notify_distants_of(dst, limit - 1)
+			else
+				atwarn("Distant signal backref is not purged: main =",main_pts,", distant =",dst,", remote =",dst_asp.remote,"")
 			end
-			local isasp = ndef.advtrains.get_aspect(pos, node)
-			
-			advtrains.interlocking.show_signal_aspect_selector(
-				pname,
-				ndef.advtrains.supported_aspects,
-				attrans("Set aspect manually"), callback,
-				isasp)
-		else
-			--static signal - only IP
-			advtrains.interlocking.show_ip_form(pos, pname)
 		end
 	end
 end
 
--- Returns the aspect the signal at pos is supposed to show
-function advtrains.interlocking.signal_get_supposed_aspect(pos)
-	local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
-	if sigd then
-		local tcbs = advtrains.interlocking.db.get_tcbs(sigd)
-		if tcbs.aspect then
-			return convert_aspect_if_necessary(tcbs.aspect)
-		end
-	end
-	return DANGER;
+function signal.notify_trains(pos)
+	local ipts, iconn = advtrains.interlocking.db.get_ip_by_signalpos(pos)
+	if not ipts then return end
+	local ipos = minetest.string_to_pos(ipts)
+
+	-- FIXME: invalidate_all_paths_ahead does not appear to always work as expected
+	--advtrains.invalidate_all_paths_ahead(ipos)
+	minetest.after(0, advtrains.invalidate_all_paths, ipos)
 end
 
--- Returns the actual aspect of the signal at position, as returned by the nodedef.
--- returns nil when there's no signal at the position
-function advtrains.interlocking.signal_get_aspect(pos)
-	local node=advtrains.ndb.get_node(pos)
-	local ndef=minetest.registered_nodes[node.name]
-	if ndef and ndef.advtrains and ndef.advtrains.get_aspect then
-		local asp = ndef.advtrains.get_aspect(pos, node)
-		if not asp then asp = DANGER end
-		return convert_aspect_if_necessary(asp)
+-- Update waiting trains and distant signals about a changed signal aspect
+-- Must be called when a signal's aspect changes through some other means
+-- and not via the signal mechanism
+function signal.notify_on_aspect_changed(pos, skip_dst_notify)
+	signal.notify_trains(pos)
+	if not skip_dst_notify then
+		signal.notify_distants_of(advtrains.encode_pos(pos), 2)
 	end
-	return nil
 end
 
--- Returns the "supported_aspects" of the signal at position, as returned by the nodedef.
--- returns nil when there's no signal at the position
-function advtrains.interlocking.signal_get_supported_aspects(pos)
-	local node=advtrains.ndb.get_node(pos)
-	local ndef=minetest.registered_nodes[node.name]
-	if ndef and ndef.advtrains and ndef.advtrains.supported_aspects then
-		local asp = ndef.advtrains.supported_aspects
-		return asp
-	end
-	return nil
+-- Gets the stored main aspect and distant signal position for this signal
+-- This information equals the information last passed to set_aspect
+-- It does not take into consideration the actual speed signalling, please use
+-- get_aspect_info() for this
+-- pos: the position of the signal
+-- returns: main_aspect, dst_pos
+function signal.get_aspect(pos)
+	local aspt = signal.aspects[advtrains.encode_pos(pos)]
+	local ma,dp = signal.get_aspect_internal(pos, aspt)
+	return ma, dp and advtrains.decode_pos(dp)
+end
+
+local function cache_mainaspects(ndefat)
+	ndefat.main_aspects_lookup = {}
+    for _,ma in ipairs(ndefat.main_aspects) do
+		ndefat.main_aspects_lookup[ma.name] = ma
+    end
+    ndefat.main_aspects_lookup[signal.MASP_HALT.name] = signal.MASP_HALT.name -- halt is always defined
+    ndefat.main_aspects_lookup[signal.MASP_DEFAULT.name] = ndefat.main_aspects[1] -- default is the first one
 end
 
-local players_assign_ip = {}
 
-local function ipmarker(ipos, connid)
-	local node_ok, conns, rhe = advtrains.get_rail_info_at(ipos, advtrains.all_tracktypes)
-	if not node_ok then return end
-	local yaw = advtrains.dir_to_angle(conns[connid].c)
+-- gets the main aspect. resolves named aspects to aspect table on demand
+function signal.get_aspect_internal(pos, aspt)
+	-- look up node and nodedef
+	local node = advtrains.ndb.get_node_or_nil(pos)
+	local ndef = node and minetest.registered_nodes[node.name]
+	if not aspt or not ndef then
+		-- oh, no main aspect, nevermind
+		return signal.MASP_HALT, nil, node, ndef
+	end
+	local ndefat = ndef.advtrains or {}
+	local masp = aspt.main or signal.MASP_HALT
 	
-	-- using tcbmarker here
-	local obj = minetest.add_entity(vector.add(ipos, {x=0, y=0.2, z=0}), "advtrains_interlocking:tcbmarker")
-	if not obj then return end
-	obj:set_yaw(yaw)
-	obj:set_properties({
-		textures = { "at_il_signal_ip.png" },
-	})
+	if type(masp) == "string" then
+		if masp=="_halt" then
+			masp = signal.MASP_HALT
+		elseif masp=="_default" and not ndefat.main_aspects then
+			-- case is fine, distant only signal
+			masp = signal.MASP_DEFAULT
+		else			
+			assert(ndefat.main_aspects, "With named aspects, node "..node.name.." needs advtrains.main_aspects table!")
+			-- resolve the main aspect from the mainaspects table
+			if not ndefat.main_aspects_lookup then
+				cache_mainaspects(ndefat)
+			end
+			masp = ndefat.main_aspects_lookup[aspt.main] or signal.MASP_DEFAULT
+		end
+	end
+	-- return whatever the main aspect is
+	return masp, aspt.remote, node, ndef
 end
 
--- shows small info form for signal IP state/assignment
--- only_notset: show only if it is not set yet (used by signal tcb assignment)
-function advtrains.interlocking.show_ip_form(pos, pname, only_notset)
-	if not minetest.check_player_privs(pname, "interlocking") then
-		return
-	end
-	local form = "size[7,5]label[0.5,0.5;" .. attrans("Signal at @1", minetest.pos_to_string(pos)).."]"
-	advtrains.interlocking.db.check_for_duplicate_ip(pos)
-	local pts, connid = advtrains.interlocking.db.get_ip_by_signalpos(pos)
-	if pts then
-		form = form.."label[0.5,1.5;" .. attrans("Influence point is set at @1/@2", pts, connid).."]"
-		form = form.."button_exit[0.5,2.5;  5,1;set;"..attrans("Move") .. "]"
-		form = form.."button_exit[0.5,3.5;  5,1;clear;" .. attrans("Clear") .. "]"
-		local ipos = minetest.string_to_pos(pts)
-		ipmarker(ipos, connid)
-	else
-		form = form.."label[0.5,1.5;" .. attrans("Influence point is not set.") .. "]"
-		form = form.."label[0.5,2.0;" .. attrans("It is recommended to set an influence point.") .. "]"
-		form = form.."label[0.5,2.5;" .. attrans("This is the point where trains will obey the signal.") .. "]"
+-- For the signal at pos, get the "aspect info" table. This contains the speed signalling information at this location
+function signal.get_aspect_info(pos)
+	-- get aspect internal
+	local aspt = signal.aspects[advtrains.encode_pos(pos)]
+	local masp, remote, node, ndef = signal.get_aspect_internal(pos, aspt)
+	-- call into ndef
+	if ndef and ndef.advtrains and ndef.advtrains.get_aspect_info then
+		local ai = ndef.advtrains.get_aspect_info
+		if type(ai)=="function" then
+			ai = ai(pos, masp)
+		end
+		if type(ai)=="table" then
+			--atdebug(pos,"aspectinfo",ai)
+			return ai
+		else
+			error("For node "..node.name..": ndef.advtrains.get_aspect_info must be function or table")
+		end
 		
-		form = form.."button_exit[0.5,3.5;  5,1;set;" .. attrans("Set") .. "]"
-	end
-	if not only_notset or not pts then
-		minetest.show_formspec(pname, "at_il_ipassign_"..minetest.pos_to_string(pos), form)
 	end
 end
 
-minetest.register_on_player_receive_fields(function(player, formname, fields)
-	local pname = player:get_player_name()
-	if not minetest.check_player_privs(pname, {train_operator=true, interlocking=true}) then
-		return
-	end
-	local pts = string.match(formname, "^at_il_ipassign_([^_]+)$")
-	local pos
-	if pts then
-		pos = minetest.string_to_pos(pts)
-	end
-	if pos then
-		if fields.set then
-			advtrains.interlocking.signal_init_ip_assign(pos, pname)
-		elseif fields.clear then
-			advtrains.interlocking.db.clear_ip_by_signalpos(pos)
+
+-- Called when either this signal has changed its main aspect
+-- or when this distant signal's currently assigned main signal has changed its aspect
+-- It retrieves the signal's main aspect and aspect info and calls apply_aspect of the node definition
+-- to update the signal's appearance and aspect info
+-- pts: The signal position to update as encoded_pos
+-- returns: the return value of the nodedef call which may be aspect_info
+function signal.reapply_aspect(pts)
+	-- get aspt
+	local aspt = signal.aspects[pts]
+	--atdebug("reapply_aspect",advtrains.decode_pos(pts),"aspt",aspt)
+	local pos = advtrains.decode_pos(pts)
+	-- resolve mainaspect table by name
+	local masp, remote, node, ndef = signal.get_aspect_internal(pos, aspt)
+	-- if we have remote, resolve remote
+	local rem_masp, rem_aspi
+	if remote then
+		-- register in remote signal as distant
+		if not signal.distant_refs[remote] then
+			signal.distant_refs[remote] = {}
+		end
+		signal.distant_refs[remote][pts] = true
+		local rem_aspt = signal.aspects[remote]
+		--atdebug("resolving remote",advtrains.decode_pos(remote),"aspt",rem_aspt)
+		local rem_pos = advtrains.decode_pos(remote)
+		local _,rem_ndef
+		rem_masp, _, _, rem_ndef = signal.get_aspect_internal(rem_pos, rem_aspt)
+		if rem_masp then
+			if rem_ndef.advtrains and rem_ndef.advtrains.get_aspect_info then
+				rem_aspi = rem_ndef.advtrains.get_aspect_info(rem_pos, rem_masp)
+			end
 		end
 	end
-end)
-
--- inits the signal IP assignment process
-function advtrains.interlocking.signal_init_ip_assign(pos, pname)
-	if not minetest.check_player_privs(pname, "interlocking") then
-		minetest.chat_send_player(pname, attrans("Insufficient privileges to use this!"))
-		return
+	-- call into ndef
+	--atdebug("applying to",pos,": main_asp",masp,"rem_masp",rem_masp,"rem_aspi",rem_aspi)
+	if ndef.advtrains and ndef.advtrains.apply_aspect then
+		ndef.advtrains.apply_aspect(pos, node, masp, rem_masp, rem_aspi)
 	end
-	--remove old IP
-	--advtrains.interlocking.db.clear_ip_by_signalpos(pos)
-	minetest.chat_send_player(pname, attrans("Configuring Signal: Please look in train's driving direction and punch rail to set influence point."))
-	
-	players_assign_ip[pname] = pos
+	-- notify trains
+	signal.notify_trains(pos)
 end
 
-minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
-	local pname = player:get_player_name()
-	if not minetest.check_player_privs(pname, "interlocking") then
-		return
-	end
-	-- IP assignment
-	local signalpos = players_assign_ip[pname]
-	if signalpos then
-		if vector.distance(pos, signalpos)<=50 then
-			local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes)
-			if node_ok and #conns == 2 then
-				
-				local yaw = player:get_look_horizontal()
-				local plconnid = advtrains.yawToClosestConn(yaw, conns)
-				
-				-- add assignment if not already present.
-				local pts = advtrains.roundfloorpts(pos)
-				if not advtrains.interlocking.db.get_ip_signal_asp(pts, plconnid) then
-					advtrains.interlocking.db.set_ip_signal(pts, plconnid, signalpos)
-					ipmarker(pos, plconnid)
-					minetest.chat_send_player(pname, attrans("Configuring Signal: Successfully set influence point"))
-				else
-					minetest.chat_send_player(pname, attrans("Configuring Signal: Influence point of another signal is already present!"))
-				end
-			else
-				minetest.chat_send_player(pname, attrans("Configuring Signal: This is not a normal two-connection rail! Aborted."))
-			end
-		else
-			minetest.chat_send_player(pname, attrans("Configuring Signal: Node is too far away. Aborted."))
+-- Update this signal's aspect based on the set route
+-- 
+function signal.update_route_aspect(tcbs, skip_dst_notify)
+	if tcbs.signal then
+		if not tcbs.route_aspect and signal.get_signal_cap_level(tcbs.signal) == 2 then
+			return
+			-- Special behavior for pure-distant signals assigned to TCBs: retain their last assigned main signal
+			-- and do not fall back to halt. This mirrors real-life, where the distant signal goes back to
+			-- expect halt only when the main signal falls into halt
 		end
-		players_assign_ip[pname] = nil
+		local asp = tcbs.route_aspect or "_halt"
+		local rem = tcbs.route_remote
+		signal.set_aspect(tcbs.signal, asp, rem, skip_dst_notify)
 	end
-end)
-
-
---== aspect selector ==--
-
-local players_aspsel = {}
+end
 
---[[
-suppasp: "supported_aspects" table
-purpose: form title string
-callback: func(pname, aspect) called on form submit
-isasp: aspect currently set
-]]
-function advtrains.interlocking.show_signal_aspect_selector(pname, p_suppasp, p_purpose, callback, isasp)
-	local suppasp = p_suppasp or {
-		main = {0, -1}, dst = {false}, shunt = false, info = {},
-	}
-	local purpose = p_purpose or ""
-	
-	local form = "size[7,7]label[0.5,0.5;" .. attrans("Select Signal Aspect:") .. "]"
-	form = form.."label[0.5,1;"..purpose.."]"
-	
-	form = form.."label[0.5,1.5;" .. attrans("== Main Signal ==") .. "]"
-	local selid = 1
-	local entries = {}
-	for idx, spv in ipairs(suppasp.main) do
-		local entry
-		if spv == 0 then
-			entry = attrans("Halt")
-		elseif spv == -1 then
-			entry = attrans("Continue at maximum speed")
-		elseif not spv then
-			entry = attrans("Continue\\, speed limit unchanged (no info)")
-		else
-			entry = attrans("Continue at speed of @1", spv)
-		end
-		-- hack: the crappy formspec system returns the label, not the index. save the index in it.
-		entries[idx] = idx.."| "..entry
-		if isasp and spv == (isasp.main or false) then
-			selid = idx
+-- Returns how capable the signal is with regards to aspect setting
+-- 0: not a signal at all
+-- 1: signal has get_aspect_info() but the aspect is not variable (e.g. a sign)
+-- 2: signal has apply_aspect() and main aspects but has "pure_distant" flag set (cannot be start/endpoint of a route, special behavior that its route aspect is not cleared on train pass)
+-- 3: signal has main signal role but can only ever display a halt aspect, such as a bumper (can be endpoint, but not startpoint, of a route)
+-- 4: Full capabilities, signal has main aspects and can be used as main/shunt signal (can be start/endpoint of a route)
+function signal.get_signal_cap_level(pos)
+	local node = advtrains.ndb.get_node_or_nil(pos)
+	local ndef = node and minetest.registered_nodes[node.name]
+	local ndefat = ndef and ndef.advtrains
+	if ndefat and ndefat.get_aspect_info then
+		if ndefat.apply_aspect and ndefat.main_aspects then
+			if not ndefat.pure_distant then
+				-- if the table contains anything, 4, otherwise 3
+				for _,_ in pairs(ndefat.main_aspects) do
+					return 4
+				end
+				return 3
+			end
+			return 2
 		end
+		return 1
 	end
-	form = form.."dropdown[0.5,2;6;main;"..table.concat(entries, ",")..";"..selid.."]"
+	return 0
+end
 
-	
-	form = form.."label[0.5,3;" .. attrans("== Shunting ==") .. "]"
-	if suppasp.shunt == nil then
-		local st = 1
-		if isasp and isasp.shunt then st=2 end
-		form = form.."dropdown[0.5,3.5;6;shunt_free;---," .. attrans("allowed") .. ";"..st.."]"
-	end
+----------------
 
-	form = form.."label[0.5,4.5;" .. attrans("== Distant Signal ==").."]"
-	local selid = 1
-	local entries = {}
-	for idx, spv in ipairs(suppasp.dst) do
-		local entry
-		if spv == 0 then
-			entry = attrans("Expect to stop at the next signal")
-		elseif spv == -1 then
-			entry = attrans("Expect to pass the next signal at maximum speed")
-		elseif not spv then
-			entry = attrans("No info")
-		else
-			entry = attrans("Expect to pass the next signal at speed of @1", string.format("%d", spv))
+function signal.can_dig(pos, player)
+	local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
+	if sigd then
+		-- check privileges
+		if not player or not minetest.check_player_privs(player:get_player_name(), "interlocking") then
+			if not player then -- intermediate debug to uncover hard-to-find bugz
+				atwarn("advtrains.interlocking.signal.can_dig(",pos,") called with player==nil!")
+			end
+			return false
 		end
-		entries[idx] = idx.."| "..entry
-		if isasp and spv == (isasp.dst or false) then
-			selid = idx
+		-- check if route is set
+		local tcbs = advtrains.interlocking.db.get_tcbs(sigd)
+		if tcbs.routeset then
+			return false
 		end
 	end
-	form = form.."dropdown[0.5,5;6;dst;"..table.concat(entries, ",")..";"..selid.."]"
-
-	form = form.."button_exit[0.5,6;5,1;save;" .. attrans("Save signal aspect") .. "]"
-	
-	local token = advtrains.random_id()
-	
-	minetest.show_formspec(pname, "at_il_sigaspdia_"..token, form)
-	
-	minetest.after(1, function()
-	players_aspsel[pname] = {
-		suppasp = suppasp,
-		callback = callback,
-		token = token,
-	}
-	end)
+	return true
 end
 
-local function usebool(sup, val, free)
-	if sup == nil then
-		return val==free
-	else
-		return sup
+function signal.after_dig(pos, oldnode, oldmetadata, player)
+	-- unassign signal if necessary
+	local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
+	if sigd then
+		advtrains.interlocking.db.unassign_signal_for_tcbs(sigd)
+		minetest.chat_send_player(player:get_player_name(), "Signal has been unassigned. Name and routes are kept for reuse.")
+	end
+	-- clear influence point
+	local ipts,iconnid = advtrains.interlocking.db.get_ip_by_signalpos(pos)
+	if ipts then
+		advtrains.interlocking.db.clear_ip_signal(ipts, iconnid)
 	end
+	advtrains.interlocking.signal.unregister_aspect(pos)
 end
 
--- other side of hack: extract the index
-local function ddindex(val)
-	return tonumber(string.match(val, "^(%d+)|"))
+function signal.on_rightclick(pos, node, player, itemstack, pointed_thing)
+	local pname = player:get_player_name()
+	local control = player:get_player_control()
+	advtrains.interlocking.show_signal_form(pos, node, pname, control.aux1)
 end
 
--- TODO use non-hacky way to parse outputs
-
-minetest.register_on_player_receive_fields(function(player, formname, fields)
-	local pname = player:get_player_name()
-	local psl = players_aspsel[pname]
-	if psl then
-		if formname == "at_il_sigaspdia_"..psl.token then
-			if fields.save then
-				local maini = ddindex(fields.main)
-				if not maini then return end
-				local dsti = ddindex(fields.dst)
-				if not dsti then return end
-				local asp = {
-					main = psl.suppasp.main[maini],
-					dst = psl.suppasp.dst[dsti],
-					shunt = usebool(psl.suppasp.shunt, fields.shunt_free, attrans("allowed")),
-					info = {}
-				}
-				psl.callback(pname, asp)
-			end
-		else
-			players_aspsel[pname] = nil
-		end
-	end
-	
-end)
+advtrains.interlocking.signal = signal
diff --git a/advtrains_interlocking/signal_aspect_ui.lua b/advtrains_interlocking/signal_aspect_ui.lua
new file mode 100644
index 0000000..98a332a
--- /dev/null
+++ b/advtrains_interlocking/signal_aspect_ui.lua
@@ -0,0 +1,281 @@
+local F = advtrains.formspec
+
+function advtrains.interlocking.show_signal_form(pos, node, pname, aux_key)
+	local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
+	if sigd and not aux_key then
+		advtrains.interlocking.show_signalling_form(sigd, pname)
+	else
+		if advtrains.interlocking.signal.get_signal_cap_level(pos) >= 2 then
+			advtrains.interlocking.show_ip_sa_form(pos, pname)
+		else
+			advtrains.interlocking.show_ip_form(pos, pname)
+		end
+	end
+end
+
+local players_assign_ip = {}
+local players_assign_distant = {}
+
+local function ipmarker(ipos, connid)
+	local node_ok, conns, rhe = advtrains.get_rail_info_at(ipos, advtrains.all_tracktypes)
+	if not node_ok then return end
+	local yaw = advtrains.dir_to_angle(conns[connid].c)
+
+	-- using tcbmarker here
+	local obj = minetest.add_entity(vector.add(ipos, {x=0, y=0.2, z=0}), "advtrains_interlocking:tcbmarker")
+	if not obj then return end
+	obj:set_yaw(yaw)
+	obj:set_properties({
+		textures = { "at_il_signal_ip.png" },
+	})
+end
+
+function advtrains.interlocking.make_ip_formspec_component(pos, x, y, w)
+	advtrains.interlocking.db.check_for_duplicate_ip(pos)
+	local pts, connid = advtrains.interlocking.db.get_ip_by_signalpos(pos)
+	if pts then
+		-- display marker
+		local ipos = minetest.string_to_pos(pts)
+		ipmarker(ipos, connid)
+		return table.concat {
+			F.S_label(x, y, "Influence point is set at @1.", string.format("%s/%s", pts, connid)),
+			F.S_button_exit(x, y+0.5, w/2-0.125, "ip_set", "Modify"),
+			F.S_button_exit(x+w/2+0.125, y+0.5, w/2-0.125, "ip_clear", "Clear"),
+		}
+	else
+		return table.concat {
+			F.S_label(x, y, "Influence point is not set."),
+			F.S_button_exit(x, y+0.5, w, "ip_set", "Set influence point"),
+		}
+	end
+end
+
+-- shows small formspec to set the signal influence point
+-- only_notset: show only if it is not set yet (used by signal tcb assignment)
+function advtrains.interlocking.show_ip_form(pos, pname, only_notset)
+	if not minetest.check_player_privs(pname, "interlocking") then
+		return
+	end
+	local ipform = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 0.5, 7)
+	local form = {
+		"formspec_version[4]",
+		"size[8,2.25]",
+		ipform,
+	}
+	if not only_notset or not pts then
+		minetest.show_formspec(pname, "at_il_ipsaform_"..minetest.pos_to_string(pos), table.concat(form))
+	end
+end
+
+-- shows larger formspec to set the signal influence point, main aspect and distant signal pos
+-- only_notset: show only if it is not set yet (used by signal tcb assignment)
+function advtrains.interlocking.show_ip_sa_form(pos, pname)
+	if not minetest.check_player_privs(pname, "interlocking") then
+		return
+	end
+	local ipform = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 0.5, 7)
+	local ma, rpos = advtrains.interlocking.signal.get_aspect(pos)
+	local form = {
+		"formspec_version[4]",
+		"size[8,4.5]",
+		ipform,
+	}
+	-- Create Signal aspect formspec elements
+	local ndef = advtrains.ndb.get_ndef(pos)
+	if ndef and ndef.advtrains then
+		form[#form+1] = F.label(0.5, 2, "Signal Aspect:")
+		-- main aspect list
+		if ndef.advtrains.main_aspects then
+			local entries = { "<none>" }
+			local sel = 1
+			for i, mae in ipairs(ndef.advtrains.main_aspects) do
+				entries[i+1] = mae.description
+				if ma and ma.name == mae.name then
+					sel = i+1
+				end
+			end
+			form[#form+1] = F.dropdown(0.5, 2.5, 4, "sa_mainaspect", entries, sel, true)
+		end
+		-- distant signal assign (is shown either when main_aspect is not none, or when pure distant signal)
+		if rpos then
+			form[#form+1] = F.button_exit(0.5, 3.5, 4, "sa_undistant", "Dst: " .. minetest.pos_to_string(rpos))
+		elseif (ma and not ma.halt) or not ndef.advtrains.main_aspects then
+			form[#form+1] = F.button_exit(0.5, 3.5, 4, "sa_distant", "<assign distant>")
+		end
+	end
+	
+	minetest.show_formspec(pname, "at_il_ipsaform_"..minetest.pos_to_string(pos), table.concat(form))
+end
+
+function advtrains.interlocking.handle_ip_sa_formspec_fields(pname, pos, fields)
+	if not (pos and minetest.check_player_privs(pname, {train_operator=true, interlocking=true})) then
+		return
+	end
+	local ma, rpos = advtrains.interlocking.signal.get_aspect(pos)
+	-- mainaspect dropdown
+	if fields.sa_mainaspect then
+		local idx = tonumber(fields.sa_mainaspect)
+		local new_ma = nil
+		if idx > 1 then
+			local ndef = advtrains.ndb.get_ndef(pos)
+			if ndef and ndef.advtrains and ndef.advtrains.main_aspects then
+				new_ma = ndef.advtrains.main_aspects[idx - 1]
+			end
+		end
+		if new_ma then
+			advtrains.interlocking.signal.set_aspect(pos, new_ma.name, rpos)
+		else
+			-- reset everything
+			advtrains.interlocking.signal.clear_aspect(pos)
+		end
+		
+	end
+	-- buttons
+	if fields.ip_set then
+		advtrains.interlocking.init_ip_assign(pos, pname)
+		return
+	elseif fields.ip_clear then
+		advtrains.interlocking.db.clear_ip_by_signalpos(pos)
+		return
+	elseif fields.sa_distant then
+		advtrains.interlocking.init_distant_assign(pos, pname)
+		return
+	elseif fields.sa_undistant then
+		advtrains.interlocking.signal.set_aspect(pos, ma.name, nil)
+		return
+	end
+	-- show the form again unless one of the buttons was clicked
+	if not fields.quit then
+		advtrains.interlocking.show_ip_sa_form(pos, pname)
+	end
+end
+
+minetest.register_on_player_receive_fields(function(player, formname, fields)
+	local pname = player:get_player_name()
+	local pts = string.match(formname, "^at_il_ipsaform_([^_]+)$")
+	local pos
+	if pts then
+		pos = minetest.string_to_pos(pts)
+	end
+	if pos then
+		advtrains.interlocking.handle_ip_sa_formspec_fields(pname, pos, fields)
+	end
+end)
+
+-- inits the signal IP assignment process
+function advtrains.interlocking.init_ip_assign(pos, pname)
+	if not minetest.check_player_privs(pname, "interlocking") then
+		minetest.chat_send_player(pname, "Insufficient privileges to use this!")
+		return
+	end
+	--remove old IP
+	--advtrains.interlocking.db.clear_ip_by_signalpos(pos)
+	minetest.chat_send_player(pname, "Configuring Signal: Please look in train's driving direction and punch rail to set influence point.")
+	
+	players_assign_ip[pname] = pos
+end
+
+-- inits the distant signal assignment process
+function advtrains.interlocking.init_distant_assign(pos, pname)
+	if not minetest.check_player_privs(pname, "interlocking") then
+		minetest.chat_send_player(pname, "Insufficient privileges to use this!")
+		return
+	end
+	minetest.chat_send_player(pname, "Set distant signal: Punch the main signal to assign!")
+	
+	players_assign_distant[pname] = pos
+end
+
+-- Tries to automatically find a TCB to assign to the signal, or a main signal if this is a pure distant signal and another signal is found before the TCB
+local function try_auto_assign_to_tcb(signalpos, pos, connid, pname)
+	local pure_distant = advtrains.interlocking.signal.get_signal_cap_level(signalpos) == 2 -- exactly 2: pure distant sig
+	local is_past_first = false
+	local ti = advtrains.get_track_iterator(pos, connid, pure_distant and 150 or 16, false) -- maximum 16 track nodes ahead
+	local apos, aconnid = ti:next_branch()
+	while apos do
+		-- check for presence of a tcb
+		local tcb = advtrains.interlocking.db.get_tcb(apos)
+		if tcb then
+			-- check on the pointing connid whether it has a signal already
+			if not tcb[aconnid].signal then
+				-- go ahead and assign
+				local sigd = { p=apos, s=aconnid }
+				advtrains.interlocking.db.assign_signal_to_tcbs(signalpos, sigd)
+				-- use auto-naming
+				advtrains.interlocking.add_autoname_to_tcbs(tcb[aconnid], pname)
+				minetest.chat_send_player(pname, "Assigned signal to the TCB at "..core.pos_to_string(apos))
+				advtrains.interlocking.show_tcb_marker(apos)
+				advtrains.interlocking.show_signalling_form(sigd, pname)
+			end
+			-- in all cases return
+			return
+		elseif pure_distant and is_past_first then
+			-- try to find another signal's influence point here which could be the remote of a distant signal
+			local pts = advtrains.roundfloorpts(apos)
+			local mainsig = advtrains.interlocking.db.get_ip_signal(pts, aconnid)
+			if mainsig and advtrains.interlocking.signal.get_signal_cap_level(mainsig) >= 3 then
+				advtrains.interlocking.signal.set_aspect(signalpos, "_default", mainsig)
+				minetest.chat_send_player(pname, "Assigned distant signal to the main signal at "..core.pos_to_string(mainsig))
+				return
+			end
+		end
+		apos, aconnid = ti:next_track()
+		is_past_first = true
+	end
+	-- if we end up here limit is up
+end
+
+minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
+	local pname = player:get_player_name()
+	if not minetest.check_player_privs(pname, "interlocking") then
+		return
+	end
+	-- IP assignment
+	local signalpos = players_assign_ip[pname]
+	if signalpos then
+		if vector.distance(pos, signalpos)<=50 then
+			local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes)
+			if node_ok and #conns == 2 then
+				
+				local yaw = player:get_look_horizontal()
+				local plconnid = advtrains.yawToClosestConn(yaw, conns)
+				
+				-- add assignment if not already present.
+				local pts = advtrains.roundfloorpts(pos)
+				if not advtrains.interlocking.db.get_ip_signal_asp(pts, plconnid) then
+					advtrains.interlocking.db.set_ip_signal(pts, plconnid, signalpos)
+					ipmarker(pos, plconnid)
+					minetest.chat_send_player(pname, "Configuring Signal: Successfully set influence point")
+					-- Try to find a TCB ahead and auto assign this signal there
+					if advtrains.interlocking.signal.get_signal_cap_level(signalpos) >= 2 then
+						try_auto_assign_to_tcb(signalpos, pos, plconnid, pname)
+					end
+				else
+					minetest.chat_send_player(pname, "Configuring Signal: Influence point of another signal is already present!")
+				end
+			else
+				minetest.chat_send_player(pname, "Configuring Signal: This is not a normal two-connection rail! Aborted.")
+			end
+		else
+			minetest.chat_send_player(pname, "Configuring Signal: Node is too far away. Aborted.")
+		end
+		players_assign_ip[pname] = nil
+	end
+	-- DST assignment
+	signalpos = players_assign_distant[pname]
+	if signalpos then
+		-- get current mainaspect
+		local ma, rpos = advtrains.interlocking.signal.get_aspect(signalpos)
+		-- if punched pos is valid signal then set it as the new remote, otherwise nil
+		local nrpos
+		if advtrains.interlocking.signal.get_signal_cap_level(pos) > 1 then
+			nrpos = pos
+			if not ma or ma.halt then -- make sure that dst is never set without a main aspect (esp. for pure distant signal case)
+				ma = "_default"
+			end
+			advtrains.interlocking.signal.set_aspect(signalpos, ma, nrpos)
+		end
+		players_assign_distant[pname] = nil
+	end
+end)
+
diff --git a/advtrains_interlocking/smartroute.lua b/advtrains_interlocking/smartroute.lua
new file mode 100644
index 0000000..f03ece0
--- /dev/null
+++ b/advtrains_interlocking/smartroute.lua
@@ -0,0 +1,257 @@
+-- smartroute.lua
+-- Implementation of the advtrains auto-route search
+
+local atil = advtrains.interlocking
+local ildb = atil.db
+local sr = {}
+
+
+-- Start the SmartRoute process. This searches for routes and tries to match them with existing routes, showing them in a form
+function sr.start(pname, sigd)
+	-- is start signal a shunt signal? This becomes default setting for searching_shunt
+	local is_startsignal_shunt = false
+	local tcbs = ildb.get_tcbs(sigd)
+	if tcbs.signal then
+		local ndef = advtrains.ndb.get_ndef(tcbs.signal)
+		if ndef and ndef.advtrains then
+			if ndef.advtrains.route_role == "shunt" then
+				is_startsignal_shunt = true
+			end
+		end
+	end
+	sr.propose_next(pname, sigd, 0, is_startsignal_shunt)
+end
+
+
+local function otherside(s)
+	if s==1 then return 2 else return 1 end
+end
+
+--route search implementation
+-- new 2025-01-06: rely on the already present info from rscache to traverse sections
+-- this allows to implement a breadth first search
+-- format of foundroute:
+-- { name = "the name", tcbseq = { list of sigds in sequence, not containing the start sigd }}
+
+local function build_route_from_foundroute(froute, name)
+	local route = {
+		name = froute.name,
+		use_rscache = true,
+		smartroute_generated = true,
+	}
+	for _, sigd in ipairs(froute.tcbseq) do
+		route[#route+1] = { next = sigd, locks = {} }
+	end
+	return route
+end
+
+-- Maximum num of sections for routes to be found
+local RTE_MAX_SECS = 16
+
+-- scan for possible routes from the start tcb in a bread-first-search manner
+-- find_more_than: search is aborted only if more than the specified number of routes are found
+function sr.rescan(pname, sigd, tcbs, find_more_than, searching_shunt, pname)
+	local found_routes = {}
+	local restart_tcbs = { {sigd = sigd, tcbseq = {} } }
+	local last_len = 0
+	while true do
+		-- take first entry out of restart_tcbs (due to the way it is inserted the first entry will always be the one with the lowest length
+		local cur_restart
+		for idx, rst in ipairs(restart_tcbs) do
+			cur_restart = rst
+			table.remove(restart_tcbs, idx)
+			break
+		end
+		if not cur_restart then
+			-- we have no candidates left. Give up and return what we have
+			--atdebug("(SR) No Candidates left, end rescan")
+			return found_routes
+		end
+		-- check if we need to stop due to having found enough routes
+		local cur_len = #cur_restart.tcbseq
+		if cur_len > last_len then
+			-- one level is finished, check if enoufh routes are found
+			if #found_routes > find_more_than then
+				--atdebug("(SR) Layer finished and enough routes found, end rescan")
+				return found_routes
+			end
+			last_len = cur_len
+		end
+		-- our current restart point is nouw in cur_restart
+		local c_sigd = cur_restart.sigd
+		--atdebug("(SR) Search continues at",c_sigd,"seqlen",#cur_restart.tcbseq)
+		-- do a TS repair, this also updates the RS cache should it be out of date
+		local c_ts_id = ildb.check_and_repair_ts_at_pos(c_sigd.p, c_sigd.s, pname, false)
+		if c_ts_id then
+			local c_ts = ildb.get_ts(c_ts_id)
+			local bgn_pts = advtrains.encode_pos(c_sigd.p)
+			local rsout = c_ts.rs_cache[bgn_pts]
+			if rsout then
+				for _, end_sigd in ipairs(c_ts.tc_breaks) do
+					end_pkey = advtrains.encode_pos(end_sigd.p)
+					if rsout[end_pkey] then
+						--atdebug("(SR) Section",c_ts_id,c_ts.name,"has way",c_sigd,"->",end_sigd)
+						local nsigd = {p=end_sigd.p, s = end_sigd.s==1 and 2 or 1} -- invert to other side
+						-- record nsigd in the tcbseq
+						local ntcbseq = table.copy(cur_restart.tcbseq)
+						ntcbseq[#ntcbseq+1] = nsigd
+						local shall_continue = true
+						-- check if that sigd is a route target
+						local tcbs = ildb.get_tcbs(nsigd)
+                        if tcbs.signal then
+							local ndef = advtrains.ndb.get_ndef(tcbs.signal)
+							if ndef and ndef.advtrains then
+								if ndef.advtrains.route_role == "main" or ndef.advtrains.route_role == "main_distant"
+											or ndef.advtrains.route_role == "end" or ndef.advtrains.route_role == "shunt" then
+									-- signal is suitable target
+									local is_mainsignal = ndef.advtrains.route_role ~= "shunt"
+									--atdebug("(SR) Suitable end signal at",nsigd,", recording route!")
+									-- record the found route in the results
+									found_routes[#found_routes+1] = {
+											tcbseq = ntcbseq,
+											shunt_route = not is_mainsignal,
+											name = tcbs.signal_name or atil.sigd_to_string(nsigd)
+									}
+									-- if this is a main signal and/or we are only searching shunt routes, stop the search here
+									if is_mainsignal or searching_shunt then
+											--atdebug("(SR) Not continuing this branch!")
+											shall_continue = false
+									end
+								end
+							end
+                        end
+						-- unless overridden, insert the next restart point
+						if shall_continue then
+							restart_tcbs[#restart_tcbs+1] =  {sigd = nsigd, tcbseq = ntcbseq } 
+						end
+					end
+				end
+			else
+				--atdebug("(SR) Section",c_ts_id,c_ts.name,"found no rscache entry for start ",bgn_pts)
+			end
+		else
+			--atdebug("(SR) Stop at",c_sigd,"because no sec ahead")
+		end
+	end
+end
+
+local players_smartroute_actions = {}
+-- Propose to pname the smartroute actions in a form, with the current settings as passed to this function
+function sr.propose_next(pname, sigd, find_more_than, searching_shunt)
+	local tcbs = ildb.get_tcbs(sigd)
+	if not tcbs or not tcbs.routes then
+		minetest.chat_send_player(pname, "Smartroute: TCBS or routes don't exist here!")
+		return
+	elseif not tcbs.ts_id then
+		minetest.chat_send_player(pname, "Smartroute: No track section directly ahead!")
+		return
+	end
+	-- Step 1: search for routes using the current settings
+	local found_routes = sr.rescan(pname, sigd, tcbs, find_more_than, searching_shunt, pname)
+	-- Step 2: store in actions table
+	players_smartroute_actions[pname] = {
+		sigd = sigd,
+		searching_shunt = searching_shunt,
+		found_routes = found_routes
+	}
+	-- step 3: build form
+	local form = "size[5,5]label[0,0;Route search: "..#found_routes.." found]"
+	local tab = {}
+	for idx, froute in ipairs(found_routes) do
+		tab[idx] = minetest.formspec_escape(froute.name.." (Len="..#froute.tcbseq..")")
+	end
+	form=form.."textlist[0.5,1;4,3;rtelist;"..table.concat(tab, ",").."]"
+	form=form.."button[0.5,4;2,1;continue;Search further]"
+	form=form.."button[2.5,4;2,1;apply;Apply]"
+	
+	minetest.show_formspec(pname, "at_il_smartroute_propose", form)
+end
+
+minetest.register_on_player_receive_fields(function(player, formname, fields)
+	local pname = player:get_player_name()
+	if not minetest.check_player_privs(pname, "interlocking") then
+		return
+	end
+	if formname ~= "at_il_smartroute_propose" then
+		return
+	end
+	-- retrieve from the storage the current search result
+	local srtab = players_smartroute_actions[pname]
+	if not srtab then
+		return
+	end
+	local sigd = srtab.sigd
+	local found_routes = srtab.found_routes
+	
+	if fields.continue then
+		-- search on, but find at least one route more
+		sr.propose_next(pname, sigd, #found_routes, srtab.searching_shunt)
+		return
+	end
+	
+	if fields.apply then
+		-- user is happy with the found routes. Proceed to save them in the signal
+		local tcbs = ildb.get_tcbs(sigd)
+		if not tcbs then return end
+		-- remove routes for endpoints for which routes already exist
+		local ex_endpts = {} -- key = sigd_to_string
+		for rtid, route in ipairs(tcbs.routes) do
+			local valid = advtrains.interlocking.check_route_valid(route, sigd)
+			local endpoint = route[#route].next -- 'next' field of the last route segment (the segment with index==len)
+			if valid and endpoint then
+				local endstr = advtrains.interlocking.sigd_to_string(endpoint)
+				--atdebug("(Smartroute) Find existing endpoint:",route.name,"ends at",endstr)
+				ex_endpts[endstr] = route.name
+			else
+				--atdebug("(Smartroute) Find existing endpoint:",route.name," not considered, endpoint",endpoint,"valid",valid)
+			end
+		end
+		local new_frte = {}
+		for _,froute in ipairs(found_routes) do
+			local endpoint = froute.tcbseq[#froute.tcbseq]
+			local endstr = advtrains.interlocking.sigd_to_string(endpoint)
+			if not ex_endpts[endstr] then
+				new_frte[#new_frte+1] = froute
+			else
+				--atdebug("(Smartroute) Throwing away",froute.name,"because endpoint",endstr,"already reached by route",ex_endpts[endstr])
+			end
+		end
+		
+		-- All remaining routes will be applied to the signal
+		local sel_rte = #tcbs.routes+1
+		for idx, froute in ipairs(new_frte) do
+			tcbs.routes[#tcbs.routes+1] = build_route_from_foundroute(froute)
+		end
+		-- if only one route present and it is newly created (there was no route before, thus sel_rte==1), make default
+		if sel_rte == 1 and #tcbs.routes == 1 then
+			local route1 = tcbs.routes[1]
+			route1.ars = {default=true}
+			-- if that only route furthermore is a suitable block signal route (1 section with no locks), set it into block signal mode
+			if #route1 == 1 then
+				local ts = tcbs.ts_id and advtrains.interlocking.db.get_ts(tcbs.ts_id)
+				if ts and #ts.tc_breaks == 2 then
+					-- check for presence of any locks
+					local epos1 = advtrains.encode_pos(ts.tc_breaks[1].p)
+					local epos2 = advtrains.encode_pos(ts.tc_breaks[2].p)
+					local haslocks =
+							(route1[1].locks and next(route1[1].locks)) -- the route itself has no locks
+							or (ts.fixed_locks and next(ts.fixed_locks)) -- the section has no fixedlocks
+							or (ts.rs_cache and ts.rs_cache[epos1] and ts.rs_cache[epos1][epos2] and next(ts.rs_cache[epos1][epos2])) -- the section has no locks in rscache
+					if not haslocks then
+						-- yeah, blocksignal!
+						route1.default_autoworking = true
+					end
+				end
+			end
+		end
+		--atdebug("Smartroute done!")
+		advtrains.interlocking.show_signalling_form(sigd, pname, sel_rte)
+		players_smartroute_actions[pname] = nil
+	end
+	if fields.quit then
+		players_smartroute_actions[pname] = nil
+	end
+end)
+
+
+advtrains.interlocking.smartroute = sr
diff --git a/advtrains_interlocking/spec/basic_signalling_spec.lua b/advtrains_interlocking/spec/basic_signalling_spec.lua
new file mode 100644
index 0000000..a4e1e3a
--- /dev/null
+++ b/advtrains_interlocking/spec/basic_signalling_spec.lua
@@ -0,0 +1,106 @@
+--[[
+This file tests a large part of the signaling system, as a lot of tests for the
+signaling system tend to overlap for various parts of the system.
+]]
+
+require("mineunit")
+mineunit("core")
+
+_G.advtrains = {
+	interlocking = {
+		aspect = fixture("../../aspect"),
+	},
+	ndb = {
+		get_node = minetest.get_node,
+		swap_node = minetest.swap_node,
+	}
+}
+
+fixture("advtrains_helpers")
+fixture("../../database")
+sourcefile("distant")
+sourcefile("signal_api")
+sourcefile("signal_aspect_accessors")
+fixture("../../demosignals")
+
+minetest.register_node("advtrains_interlocking:signal_sign", {
+	advtrains = {
+		get_aspcet = function() return {main = 19} end
+	}
+})
+
+local D = advtrains.distant
+local I = advtrains.interlocking
+local A = I.aspect
+
+local stub_aspect_t1 = {
+	free = {main = -1},
+	slow = {main = 6},
+	danger = {main = 0, shunt = false},
+}
+for k, v in pairs(stub_aspect_t1) do
+	stub_aspect_t1[k] = A(v)
+end
+local stub_pos_t1 = {}
+for i = 1, 4 do
+	stub_pos_t1[i] = {x = 1, y = 0, z = i}
+end
+
+world.layout {
+	{stub_pos_t1[1], "advtrains_interlocking:ds_danger"},
+	{stub_pos_t1[2], "advtrains_interlocking:ds_slow"},
+	{stub_pos_t1[3], "advtrains_interlocking:ds_free"},
+	{stub_pos_t1[4], "advtrains_interlocking:signal_sign"},
+}
+
+describe("API for supposed signal aspects", function()
+	it("should load and save data properly", function()
+		local tbl = {_foo = {}}
+		I.load_supposed_aspects(tbl)
+		assert.same(tbl, I.save_supposed_aspects())
+	end)
+	it("should set and get signals properly", function ()
+		local pos = stub_pos_t1[2]
+		local asp = stub_aspect_t1.slow
+		local newasp = A{ main = math.random(1,5) }
+		assert.equal(asp, I.signal_get_aspect(pos))
+		I.signal_set_aspect(pos, newasp)
+		assert.equal(newasp, I.signal_get_aspect(pos))
+		assert.equal(asp, I.signal_get_real_aspect(pos))
+		I.signal_set_aspect(pos, asp)
+	end)
+end)
+
+describe("Distant signaling", function()
+	it("should assign distant signals and set the distant aspect correspondingly", function()
+		for i = 1, 2 do
+			D.assign(stub_pos_t1[i], stub_pos_t1[i+1])
+		end
+		assert.equal(stub_aspect_t1.danger, I.signal_get_aspect(stub_pos_t1[1]))
+		assert.equal(A{main = 6, dst = 0}, I.signal_get_aspect(stub_pos_t1[2]))
+		assert.equal(A{main = -1, dst = 6}, I.signal_get_aspect(stub_pos_t1[3]))
+	end)
+	it("should report assignments properly", function()
+		assert.same({stub_pos_t1[1], "manual"}, {D.get_main(stub_pos_t1[2])})
+		assert.same({[advtrains.encode_pos(stub_pos_t1[3])] = "manual"}, D.get_dst(stub_pos_t1[2]))
+	end)
+	it("should update distant aspects automatically", function()
+		I.signal_set_aspect(stub_pos_t1[2], {main = 2, dst = -1})
+		assert.equal(A{main = 2, dst = 0}, I.signal_get_aspect(stub_pos_t1[2]))
+		assert.equal(A{main = -1, dst = 2}, I.signal_get_aspect(stub_pos_t1[3]))
+	end)
+	it("should unassign signals when one is removed", function()
+		world.set_node(stub_pos_t1[2], "air")
+		assert.same({}, D.get_dst(stub_pos_t1[1]))
+		assert.same({}, {D.get_main(stub_pos_t1[3])})
+		assert.same(stub_aspect_t1.free, I.signal_get_aspect(stub_pos_t1[3]))
+	end)
+	it("should reject signal signs", function()
+		D.assign(stub_pos_t1[1], stub_pos_t1[4])
+		assert.same({}, D.get_dst(stub_pos_t1[1]))
+		assert.same({}, {D.get_main(stub_pos_t1[4])})
+		D.assign(stub_pos_t1[4], stub_pos_t1[1])
+		assert.same({}, D.get_dst(stub_pos_t1[4]))
+		assert.same({}, {D.get_main(stub_pos_t1[1])})
+	end)
+end)
diff --git a/advtrains_interlocking/spec/fixtures/advtrains_helpers.lua b/advtrains_interlocking/spec/fixtures/advtrains_helpers.lua
new file mode 120000
index 0000000..9b0ab67
--- /dev/null
+++ b/advtrains_interlocking/spec/fixtures/advtrains_helpers.lua
@@ -0,0 +1 @@
+../../../advtrains/helpers.lua
\ No newline at end of file
diff --git a/advtrains_interlocking/spec/mineunit.conf b/advtrains_interlocking/spec/mineunit.conf
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/advtrains_interlocking/spec/mineunit.conf
diff --git a/advtrains_interlocking/spec/signal_group_spec.lua b/advtrains_interlocking/spec/signal_group_spec.lua
new file mode 100644
index 0000000..bc9d007
--- /dev/null
+++ b/advtrains_interlocking/spec/signal_group_spec.lua
@@ -0,0 +1,95 @@
+require "mineunit"
+mineunit("core")
+
+_G.advtrains = {
+	interlocking = {
+		aspect = sourcefile("aspect"),
+	},
+	ndb = {
+		get_node = minetest.get_node,
+		swap_node = minetest.swap_node,
+	}
+}
+
+fixture("advtrains_helpers")
+sourcefile("database")
+sourcefile("signal_api")
+sourcefile("distant")
+sourcefile("signal_aspect_accessors")
+
+local A = advtrains.interlocking.aspect
+local D = advtrains.distant
+local I = advtrains.interlocking
+local N = advtrains.ndb
+
+local groupdef = {
+	name = "foo",
+	aspects = {
+		proceed = {main = -1},
+		caution = {},
+		danger = {main = 0},
+		"proceed",
+		{"caution"},
+		"danger",
+	},
+}
+
+for k, v in pairs(groupdef.aspects) do
+	minetest.register_node("advtrains_interlocking:" .. k, {
+		advtrains = {
+			supported_aspects = {
+				group = "foo",
+			},
+			get_aspect = function() return A{group = "foo", name = k} end,
+			set_aspect = function(pos, _, name)
+				N.swap_node(pos, {name = "advtrains_interlocking:" .. name})
+			end,
+		}
+	})
+end
+
+local origin = vector.new(0, 0, 0)
+local dstpos = vector.new(0, 0, 1)
+
+world.layout {
+	{origin, "advtrains_interlocking:danger"},
+	{dstpos, "advtrains_interlocking:proceed"},
+}
+
+describe("signal group registration", function()
+	it("should work", function()
+		A.register_group(groupdef)
+		assert(A.get_group_definition("foo"))
+	end)
+	it("should only be allowed once for the same group", function()
+		assert.has.errors(function() A.register_group(type2def) end)
+	end)
+	it("should handle nonexistant groups", function()
+		assert.is_nil(A.get_group_definition("something_else"))
+	end)
+	it("should reject invalid definitions", function()
+		assert.has.errors(function() A.register_group({}) end)
+		assert.has.errors(function() A.register_group({name="",label={}}) end)
+		assert.has.errors(function() A.register_group({name="",aspects={}}) end)
+	end)
+end)
+
+describe("signal aspect", function()
+	it("should handle empty fields properly", function()
+		assert.equal(A{main = 0}, A{group="foo", name="danger"}:to_group())
+	end)
+	it("should be converted properly", function()
+		assert.equal(A{main = 0}, A{group="foo", name="danger"})
+		assert.equal(A{}, A{group="foo", name="caution"})
+		assert.equal(A{main = -1}, A{group="foo", name="proceed"})
+	end)
+end)
+
+describe("signals in groups", function()
+	it("should support distant signaling", function()
+		assert.equal("caution", A():adjust_distant(A{group="foo",name="danger"}).name)
+		assert.equal("proceed", A():adjust_distant(A{group="foo",name="caution"}).name)
+		assert.equal("proceed", A():adjust_distant(A{group="foo",name="proceed"}).name)
+		assert.equal("danger", A{group="foo",name="danger"}:adjust_distant{}.name)
+	end)
+end)
diff --git a/advtrains_interlocking/tcb_ts_ui.lua b/advtrains_interlocking/tcb_ts_ui.lua
index 263a1f0..9a44b4d 100644
--- a/advtrains_interlocking/tcb_ts_ui.lua
+++ b/advtrains_interlocking/tcb_ts_ui.lua
@@ -2,8 +2,11 @@
 
 local players_assign_tcb = {}
 local players_assign_signal = {}
+local players_assign_xlink = {}
 local players_link_ts = {}
+local players_assign_fixedlocks = {}
 
+local atil = advtrains.interlocking
 local ildb = advtrains.interlocking.db
 local ilrs = advtrains.interlocking.route
 
@@ -14,6 +17,7 @@ local lntrans = { "A", "B" }
 local function sigd_to_string(sigd)
 	return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s]
 end
+advtrains.interlocking.sigd_to_string = sigd_to_string
 
 minetest.register_node("advtrains_interlocking:tcb_node", {
 	drawtype = "mesh",
@@ -88,12 +92,8 @@ minetest.register_node("advtrains_interlocking:tcb_node", {
 			local tcb = ildb.get_tcb(tcbpos)
 			if not tcb then return true end
 			for connid=1,2 do
-				if tcb[connid].ts_id or tcb[connid].signal then
-					minetest.chat_send_player(pname, attrans("Can't remove TCB: Both sides must have no track section and no signal assigned!"))
-					return false
-				end
-				if not ildb.may_modify_tcbs(tcb[connid]) then
-					minetest.chat_send_player(pname, attrans("Can't remove TCB: Side @1 forbids modification (shouldn't happen).", connid))
+				if tcb[connid].signal then
+					minetest.chat_send_player(pname, attrans("Can't remove TCB: Both sides must have no signal assigned!"))
 					return false
 				end
 			end
@@ -102,18 +102,11 @@ minetest.register_node("advtrains_interlocking:tcb_node", {
 	end,
 	after_dig_node = function(pos, oldnode, oldmetadata, player)
 		if not oldmetadata or not oldmetadata.fields then return end
+		local pname = player:get_player_name()
 		local tcbpts = oldmetadata.fields.tcb_pos
 		if tcbpts and tcbpts ~= "" then
 			local tcbpos = minetest.string_to_pos(tcbpts)
-			local success = ildb.remove_tcb(tcbpos)
-			if success and player then
-				minetest.chat_send_player(player:get_player_name(), attrans("TCB has been removed."))
-			else
-				minetest.chat_send_player(player:get_player_name(), attrans("Failed to remove TCB!"))
-				minetest.set_node(pos, oldnode)
-				local meta = minetest.get_meta(pos)
-				meta:set_string("tcb_pos", minetest.pos_to_string(tcbpos))
-			end
+			ildb.remove_tcb_at(tcbpos, pname)
 		end
 	end,
 })
@@ -165,23 +158,22 @@ minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 	local tcbnpos = players_assign_tcb[pname]
 	if tcbnpos then
 		if vector.distance(pos, tcbnpos)<=20 then
-			local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes)
+			local node_ok, conns, rhe = advtrains.get_rail_info_at(pos)
 			if node_ok and #conns == 2 then
-				local ok = ildb.create_tcb(pos)
-				
-				if not ok then
-					minetest.chat_send_player(pname, attrans("Configuring TCB: TCB already exists at this position! It has now been re-assigned."))
+				-- if there is already a tcb here, reassign it
+				if ildb.get_tcb(pos) then
+					minetest.chat_send_player(pname, "Configuring TCB: Already existed at this position, it is now linked to this TCB marker")
+				else
+					ildb.create_tcb_at(pos, pname)
 				end
-				
-				ildb.sync_tcb_neighbors(pos, 1)
-				ildb.sync_tcb_neighbors(pos, 2)
-				
+
 				local meta = minetest.get_meta(tcbnpos)
 				meta:set_string("tcb_pos", minetest.pos_to_string(pos))
 				meta:set_string("infotext", attrans("TCB assigned to @1", minetest.pos_to_string(pos)))
 				minetest.chat_send_player(pname, attrans("Configuring TCB: Successfully configured TCB"))
+				advtrains.interlocking.show_tcb_marker(pos)
 			else
-				minetest.chat_send_player(pname, attrans("Configuring TCB: This is not a normal two-connection rail! Aborted."))
+				minetest.chat_send_player(pname, "Configuring TCB: This is not a normal two-connection rail! Aborted.")
 			end
 		else
 			minetest.chat_send_player(pname, attrans("Configuring TCB: Node is too far away. Aborted."))
@@ -196,18 +188,13 @@ minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 			local is_signal = minetest.get_item_group(node.name, "advtrains_signal") >= 2
 			if is_signal then
 				local ndef = minetest.registered_nodes[node.name]
-				if ndef and ndef.advtrains and ndef.advtrains.set_aspect then
+				if ndef and ndef.advtrains and ndef.advtrains.apply_aspect then
 					local tcbs = ildb.get_tcbs(sigd)
 					if tcbs then
-						tcbs.signal = pos
-						if not tcbs.signal_name then
-							tcbs.signal_name = minetest.pos_to_string(sigd.p)
-						end
-						if not tcbs.routes then
-							tcbs.routes = {}
-						end
-						ildb.set_sigd_for_signal(pos, sigd)
-						minetest.chat_send_player(pname, attrans("Configuring TCB: Successfully assigned signal."))
+						ildb.assign_signal_to_tcbs(pos, sigd)
+						-- use auto-naming
+						advtrains.interlocking.add_autoname_to_tcbs(tcbs, pname)
+						minetest.chat_send_player(pname, "Configuring TCB: Successfully assigned signal.")
 						advtrains.interlocking.show_ip_form(pos, pname, true)
 					else
 						minetest.chat_send_player(pname, attrans("Configuring TCB: Internal error, TCBS doesn't exist. Aborted."))
@@ -223,40 +210,201 @@ minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 		end
 		players_assign_signal[pname] = nil
 	end
+	
+	-- FixedLocks assignment
+	local ts_id = players_assign_fixedlocks[pname]
+	if ts_id then
+		if advtrains.is_passive(pos) then
+			local pts = advtrains.encode_pos(pos)
+			local state = advtrains.getstate(pos)
+			local ts = ildb.get_ts(ts_id)
+			if ts and ts.fixed_locks then
+				minetest.chat_send_player(pname, minetest.pos_to_string(pos).." locks in state "..state)
+				ts.fixed_locks[pts] = state
+			else
+				minetest.chat_send_player(pname, "Error: TS modified, abort!")
+				players_assign_fixedlocks[pname] = nil
+			end
+		else
+			minetest.chat_send_player(pname, "Setting fixed locks finished!")
+			players_assign_fixedlocks[pname] = nil
+			ildb.update_rs_cache(ts_id)
+			advtrains.interlocking.show_ts_form(ts_id, pname)
+		end
+	end
 end)
 
+-- "Self-contained TCB"
+-- 2024-11-25: Buffers should become their own TCB (and signal) automatically to permit setting routes to them
+-- These are support functions for this kind of node.
+
+-- Create an after_place_node callback for a self-contained TCB node. The parameters control additional behavior:
+-- fail_silently_on_noprivs: (boolean) Does not give an error in case the placer does not have the interlocking privilege
+-- auto_create_self_signal: (boolean) Automatically assign this same node as signal to the A side of the newly-created TCB
+--                          (this is useful for buffers as they serve both as TCB and as an always-halt signal)
+function advtrains.interlocking.self_tcb_make_after_place_callback(fail_silently_on_noprivs, auto_create_self_signal)
+	return function(pos, player, itemstack, pointed_thing)
+		local pname = player:get_player_name()
+		if not minetest.check_player_privs(pname, "interlocking") then
+			if not fail_silently_on_noprivs then
+				minetest.chat_send_player(pname, "Insufficient privileges to use this!")
+			end
+			return
+		end
+		if ildb.get_tcb(pos) then
+			minetest.chat_send_player(pname, "TCB already existed at this position, now linked to this node")
+		else
+			ildb.create_tcb_at(pos, pname)
+		end
+		if auto_create_self_signal then
+			local sigd = { p = pos, s = 1 }
+			local tcbs = ildb.get_tcbs(sigd)
+			-- make sure signal doesn't already exist
+			if tcbs.signal then
+				minetest.chat_send_player(pname, "Signal on B side already assigned!")
+				return
+			end
+			ildb.assign_signal_to_tcbs(pos, sigd)
+			-- assign influence point to itself
+			ildb.set_ip_signal(advtrains.roundfloorpts(pos), 1, pos)
+			-- use auto-naming
+			advtrains.interlocking.add_autoname_to_tcbs(tcbs, pname)
+		end
+	end
+end
+
+-- Create an can_dig callback for a self-contained TCB node. The parameters control additional behavior:
+-- is_signal: (boolean) Whether this node is also a signal (in addition to being a TCB), e.g. when auto_create_self_signal was set.
+--            Causes also the signal API's can_dig to be called
+function advtrains.interlocking.self_tcb_make_can_dig_callback(is_signal)
+	return function(pos, player)
+		local pname = player and player:get_player_name() or ""
+		-- need to duplicate logic of the regular "can_dig_or_modify_track()" function in core/tracks.lua
+		if advtrains.get_train_at_pos(pos) then
+			minetest.chat_send_player(pname, "Can't remove track, a train is here!")
+			return false
+		end
+		-- end of standard checks
+		local tcb = ildb.get_tcb(pos)
+		if not tcb then
+			-- digging always allowed because the TCB hasn't been created (unless signal callback interjects)
+			if is_signal then
+				return advtrains.interlocking.signal.can_dig(pos, player)
+			else
+				return true
+			end
+		end
+		-- TCB exists
+		if not minetest.check_player_privs(pname, "interlocking") then
+			return false
+		end
+		-- fine to remove (unless signal callback interjects)
+		if is_signal then
+			return advtrains.interlocking.signal.can_dig(pos, player)
+		else
+			return true
+		end
+	end
+end
+
+-- Create an after_dig_node callback for a self-contained TCB node. The parameters control additional behavior:
+-- is_signal: (boolean) Whether this node is also a signal (in addition to being a TCB), e.g. when auto_create_self_signal was set.
+--            Causes also the signal API's after_dig_node to be called
+function advtrains.interlocking.self_tcb_make_after_dig_callback(is_signal)
+	return function(pos, oldnode, oldmetadata, player)
+		local pname = player:get_player_name()
+		if is_signal then
+			-- "dig" the signal first
+			advtrains.interlocking.signal.after_dig(pos, oldnode, oldmetadata, player)
+		end
+		if ildb.get_tcb(pos) then
+			-- remove the TCB
+			ildb.remove_tcb_at(pos, pname, true)
+		end
+	end
+end
+
+-- Create an on_rightclick callback for a self-contained TCB node. The rightclick callback tries to repeat the TCB assignment
+-- if necessary and otherwise shows the TCB formspec. The parameters control additional behavior:
+-- fail_silently_on_noprivs: (boolean) Does not give an error in case the placer does not have the interlocking privilege
+-- auto_create_self_signal: (boolean) Automatically assign this same node as signal to the B side of the
+--                           newly-created TCB if that has not already happened during place.
+--                           Otherwise, opens the signal dialog instead of the TCB dialog on rightclick
+function advtrains.interlocking.self_tcb_make_on_rightclick_callback(fail_silently_on_noprivs, auto_create_self_signal)
+	return function(pos, node, player, itemstack, pointed_thing)
+		local pname = player:get_player_name()
+		if not minetest.check_player_privs(pname, "interlocking") then
+			if not fail_silently_on_noprivs then
+				minetest.chat_send_player(pname, "Insufficient privileges to use this!")
+			end
+			return
+		end
+		if ildb.get_tcb(pos) then
+			-- TCB already here. go on
+		else
+			-- otherwise create tcb
+			ildb.create_tcb_at(pos, pname)
+		end
+		if auto_create_self_signal then
+			local sigd = { p = pos, s = 1 }
+			local tcbs = ildb.get_tcbs(sigd)
+			-- make sure signal doesn't already exist
+			if not tcbs.signal then
+				-- go ahead and assign signal
+				ildb.assign_signal_to_tcbs(pos, sigd)
+				-- assign influence point to itself
+				ildb.set_ip_signal(advtrains.roundfloorpts(pos), 1, pos)
+				-- use auto-naming
+				advtrains.interlocking.add_autoname_to_tcbs(tcbs, pname)
+			end
+			-- in any case open the signalling form nouw
+			local control = player:get_player_control()
+			advtrains.interlocking.show_signal_form(pos, node, pname, control.aux1)
+			return
+		else
+			-- not an autosignal. Then show the TCB form
+			advtrains.interlocking.show_tcb_form(pos, pname)
+			return
+		end
+	end
+end
+
 -- TCB Form
 
 local sidecolorA = minetest.get_color_escape_sequence("#f40000")
 local sidecolorB = minetest.get_color_escape_sequence("#068b00")
 
-local function mktcbformspec(tcbs, btnpref, offset, pname)
+local function mktcbformspec(pos, side, tcbs, offset, pname)
 	local form = ""
+	local btnpref = side==1 and "A" or "B"
 	local ts
-	local sidecolor = sidecolorB
-	if btnpref == "A" then
-		sidecolor = sidecolorA
-	end
+	-- ensure that mapping and xlink are up to date
+	ildb.tcbs_ensure_ts_ref_exists({p=pos, s=side, tcbs=tcbs})
+	ildb.validate_tcb_xlink({p=pos, s=side, tcbs=tcbs})
+	-- Note: repair operations may have been triggered by this
 	if tcbs.ts_id then
 		ts = ildb.get_ts(tcbs.ts_id)
 	end
 	if ts then
-		form = form.."label[0.5,"..offset..";"..sidecolor..attrans("Side @1", btnpref)..": "..minetest.formspec_escape(ts.name).."]"
-		form = form.."button[0.5,"..(offset+0.5)..";5,1;"..btnpref.."_gotots;"..attrans("Show track section").."]"
-		if ildb.may_modify_tcbs(tcbs) then
-			-- Note: the security check to prohibit those actions is located in database.lua in the corresponding functions.
-			form = form.."button[0.5,"..(offset+1.5)..";2.5,1;"..btnpref.."_update;"..attrans("Update near TCBs").."]"
-			form = form.."button[3  ,"..(offset+1.5)..";2.5,1;"..btnpref.."_remove;"..attrans("Remove from section").."]"
-		end
+		form = form.."label[0.5,"..offset..";Side "..btnpref..": "..minetest.formspec_escape(ts.name or tcbs.ts_id).."]"
+		form = form.."button[0.5,"..(offset+0.5)..";5,1;"..btnpref.."_gotots;Show track section]"
 	else
 		tcbs.ts_id = nil
-		form = form.."label[0.5,"..offset..";"..sidecolor.."Strana "..btnpref..": "..attrans("End of interlocking").."]"
-		form = form.."button[0.5,"..(offset+0.5)..";5,1;"..btnpref.."_makeil;"..attrans("Create Interlocked Track Section").."]"
-		--if tcbs.section_free then
-			--form = form.."button[0.5,"..(offset+1.5)..";5,1;"..btnpref.."_setlocked;Section is free]"
-		--else
-			--form = form.."button[0.5,"..(offset+1.5)..";5,1;"..btnpref.."_setfree;Section is blocked]"		
-		--end
+		form = form.."label[0.5,"..offset..";Side "..btnpref..": ".."End of interlocking]"
+		form = form.."button[0.5,"..(offset+0.5)..";5,1;"..btnpref.."_makeil;Create Interlocked Track Section]"
+	end
+	-- xlink
+	if tcbs.xlink then
+		form = form.."label[0.5,"..(offset+1.5)..";Link:"..ildb.sigd_to_string(tcbs.xlink).."]"
+		form = form.."button[4.5,"..(offset+1.5)..";1,1;"..btnpref.."_xlinkdel;X]"
+	else
+		if players_assign_xlink[pname] then
+			form = form.."button[0.5,"..(offset+1.5)..";4,1;"..btnpref.."_xlinklink;Link "..ildb.sigd_to_string(players_assign_xlink[pname]).."]"
+			form = form.."button[4.5,"..(offset+1.5)..";1,1;"..btnpref.."_xlinkabrt;X]"
+		else
+			form = form.."label[0.5,"..(offset+1.5)..";No Link]"
+			form = form.."button[4.5,"..(offset+1.5)..";1,1;"..btnpref.."_xlinkadd;+]"
+		end
 	end
 	if tcbs.signal then
 		form = form.."button[0.5,"..(offset+2.5)..";5,1;"..btnpref.."_sigdia;"..attrans("Signalling").."]"	
@@ -276,8 +424,8 @@ function advtrains.interlocking.show_tcb_form(pos, pname)
 	if not tcb then return end
 	
 	local form = "size[6,9] label[0.5,0.5;"..attrans("Track Circuit Break Configuration").."]"
-	form = form .. mktcbformspec(tcb[1], "A", 1, pname)
-	form = form .. mktcbformspec(tcb[2], "B", 5, pname)
+	form = form .. mktcbformspec(pos, 1, tcb[1], 1, pname)
+	form = form .. mktcbformspec(pos, 2, tcb[2], 5, pname)
 	
 	minetest.show_formspec(pname, "at_il_tcbconfig_"..minetest.pos_to_string(pos), form)
 	advtrains.interlocking.show_tcb_marker(pos)
@@ -304,13 +452,13 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		local tcb = ildb.get_tcb(pos)
 		if not tcb then return end
 		local f_gotots = {fields.A_gotots, fields.B_gotots}
-		local f_update = {fields.A_update, fields.B_update}
-		local f_remove = {fields.A_remove, fields.B_remove}
 		local f_makeil = {fields.A_makeil, fields.B_makeil}
-		local f_setlocked = {fields.A_setlocked, fields.B_setlocked}
-		local f_setfree = {fields.A_setfree, fields.B_setfree}
 		local f_asnsig = {fields.A_asnsig, fields.B_asnsig}
 		local f_sigdia = {fields.A_sigdia, fields.B_sigdia}
+		local f_xlinkadd = {fields.A_xlinkadd, fields.B_xlinkadd}
+		local f_xlinkdel = {fields.A_xlinkdel, fields.B_xlinkdel}
+		local f_xlinklink = {fields.A_xlinklink, fields.B_xlinklink}
+		local f_xlinkabrt = {fields.A_xlinkabrt, fields.B_xlinkabrt}
 		
 		for connid=1,2 do
 			local tcbs = tcb[connid]
@@ -319,28 +467,33 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 					advtrains.interlocking.show_ts_form(tcbs.ts_id, pname)
 					return
 				end
-				if f_update[connid] then
-					ildb.sync_tcb_neighbors(pos, connid)
-				end
-				if f_remove[connid] then
-					ildb.remove_from_interlocking({p=pos, s=connid})
-				end
 			else
 				if f_makeil[connid] then
-					-- try sinc_tcb_neighbors first
-					ildb.sync_tcb_neighbors(pos, connid)
-					-- if that didn't work, create new section
 					if not tcbs.ts_id then
-						ildb.create_ts({p=pos, s=connid})
-						ildb.sync_tcb_neighbors(pos, connid)
+						ildb.create_ts_from_tcbs({p=pos, s=connid})
 					end
 				end
-				-- non-interlocked
-				if f_setfree[connid] then
-					tcbs.section_free = true
+			end
+			if tcbs.xlink then
+				if f_xlinkdel[connid] then
+					ildb.remove_tcb_xlink({p=pos, s=connid})
 				end
-				if f_setlocked[connid] then
-					tcbs.section_free = nil
+			else
+				local osigd = players_assign_xlink[pname]
+				if osigd then
+					if f_xlinklink[connid] then
+						ildb.add_tcb_xlink({p=pos, s=connid}, osigd)
+						players_assign_xlink[pname] = nil
+					elseif f_xlinkabrt[connid] then
+						players_assign_xlink[pname] = nil
+					end
+				else
+					if f_xlinkadd[connid] then
+						players_assign_xlink[pname] = {p=pos, s=connid}
+						minetest.chat_send_player(pname, "TCB Link: Select linked TCB now!")
+						minetest.close_formspec(pname, formname)
+						return -- to not reopen form
+					end
 				end
 			end
 			if f_asnsig[connid] and not tcbs.signal then
@@ -364,10 +517,7 @@ end)
 
 -- TS Formspec
 
--- textlist selection temporary storage
-local ts_pselidx = {}
-
-function advtrains.interlocking.show_ts_form(ts_id, pname, sel_tcb)
+function advtrains.interlocking.show_ts_form(ts_id, pname)
 	if not minetest.check_player_privs(pname, "interlocking") then
 		minetest.chat_send_player(pname, attrans("Insufficient privileges to use this!"))
 		return
@@ -386,29 +536,27 @@ function advtrains.interlocking.show_ts_form(ts_id, pname, sel_tcb)
 		advtrains.interlocking.show_tcb_marker(sigd.p)
 	end
 	
-	form = form.."textlist[0.5,3;5,3;tcblist;"..table.concat(strtab, ",").."]"
+	form = form.."label[0.5,2.5;Boundary TCBs:]"
+	form = form.."textlist[0.5,3;4,3;tcblist;"..table.concat(strtab, ",").."]"
+	
+	-- additional route locks (e.g. for level crossings)
+	
+	strtab = {}
+	if ts.fixed_locks then
+		for pts, state in pairs(ts.fixed_locks) do
+			strtab[#strtab+1] = minetest.formspec_escape(
+				minetest.pos_to_string(advtrains.decode_pos(pts)).." = "..state)
+		end
+	end
+	form = form.."label[5.5,2.5;Fixed route locks (e.g. level crossings):]"
+	form = form.."textlist[5.5,3;4,3;fixedlocks;"..table.concat(strtab, ",").."]"
 	
 	if ildb.may_modify_ts(ts) then
+		form = form.."button[5.5,6;2,1;flk_add;Add locks]"
+		form = form.."button[7.5,6;2,1;flk_clear;Clear locks]"
 		
-		if players_link_ts[pname] then
-			local other_id = players_link_ts[pname]
-			local other_ts = ildb.get_ts(other_id)
-			if other_ts then
-				if ildb.may_modify_ts(other_ts) then
-					form = form.."button[5.5,3;3.5,1;mklink;"..attrans("Join with @1", minetest.formspec_escape(other_ts.name)).."]"
-					form = form.."button[9  ,3;0.5,1;cancellink;X]"
-				end
-			end
-		else
-			form = form.."button[5.5,3;4,1;link;"..attrans("Join into other section").."]"
-			hint = 1
-		end
-		form = form.."button[5.5,4;4,1;dissolve;"..attrans("Dissolve Section").."]"
-		form = form.."tooltip[dissolve;"..attrans("This will remove the track section and set all its end points to End Of Interlocking").."]"
-		if sel_tcb then
-			form = form.."button[5.5,5;4,1;del_tcb;"..attrans("Unlink selected TCB").."]"
-			hint = 2
-		end
+		form = form.."button[5.5,8;4,1;remove;Remove Section]"
+		form = form.."tooltip[remove;This will remove the track section and set all its end points to End Of Interlocking]"
 	else
 		hint=3
 	end
@@ -426,18 +574,13 @@ function advtrains.interlocking.show_ts_form(ts_id, pname, sel_tcb)
 		form = form.."label[0.5,7.1;"..attrans("No trains on this section.").."]"
 	end
 	
-	form = form.."button[5.5,7;4,1;reset;"..attrans("Reset section state").."]"
-	
-	if hint == 1 then
-		form = form.."label[0.5,0.75;"..attrans("Use the 'Join' button to designate rail crosses and link not listed far-away TCBs").."]"
-	elseif hint == 2 then
-		form = form.."label[0.5,0.75;"..attrans("Unlinking a TCB will set it to non-interlocked mode.").."]"
-	elseif hint == 3 then
-		form = form.."label[0.5,0.75;"..attrans("You cannot modify track sections when a route is set or a train is on the section.").."]"
+	form = form.."button[5.5,7;4,1;reset;Reset section state]"
+
+	if hint == 3 then
+		form = form.."label[0.5,0.75;You cannot modify track sections when a route is set or a train is on the section.]"
 		--form = form.."label[0.5,1;Trying to unlink a TCB directly connected to this track will not work.]"
 	end
 	
-	ts_pselidx[pname]=sel_tcb
 	minetest.show_formspec(pname, "at_il_tsconfig_"..ts_id, form)
 	
 end
@@ -449,45 +592,15 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		return
 	end
 	-- independent of the formspec, clear this whenever some formspec event happens
-	local tpsi = ts_pselidx[pname]
-	ts_pselidx[pname] = nil
 	
 	local ts_id = string.match(formname, "^at_il_tsconfig_(.+)$")
 	if ts_id and not fields.quit then
 		local ts = ildb.get_ts(ts_id)
 		if not ts then return end
 		
-		local sel_tcb
-		if fields.tcblist then
-			local tev = minetest.explode_textlist_event(fields.tcblist)
-			sel_tcb = tev.index
-			ts_pselidx[pname] = sel_tcb
-		elseif tpsi then
-			sel_tcb = tpsi
-		end
-		
 		if ildb.may_modify_ts(ts) then
-			if players_link_ts[pname] then
-				if fields.cancellink then
-					players_link_ts[pname] = nil
-				elseif fields.mklink then
-					ildb.link_track_sections(players_link_ts[pname], ts_id)
-					players_link_ts[pname] = nil
-				end
-			end
-			
-			if fields.del_tcb and sel_tcb and sel_tcb > 0 and sel_tcb <= #ts.tc_breaks then
-				if not ildb.remove_from_interlocking(ts.tc_breaks[sel_tcb]) then
-					minetest.chat_send_player(pname, attrans("Please unassign signal first!"))
-				end
-				sel_tcb = nil
-			end
-			
-			if fields.link then
-				players_link_ts[pname] = ts_id
-			end
-			if fields.dissolve then
-				ildb.dissolve_ts(ts_id)
+			if fields.remove then
+				ildb.remove_ts(ts_id)
 				minetest.close_formspec(pname, formname)
 				return
 			end
@@ -496,10 +609,22 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		if fields.setname then
 			ts.name = fields.name
 			if ts.name == "" then
-				ts.name = ts_id
+				ts.name = nil
 			end
 		end
 		
+		if fields.flk_add then
+			if not ts.fixed_locks then
+				ts.fixed_locks = {}
+			end
+			players_assign_fixedlocks[pname] = ts_id
+			minetest.chat_send_player(pname, "Punch components to add fixed locks. (punch anything else = end)")
+			minetest.close_formspec(pname, formname)
+			return
+		elseif fields.flk_clear then
+			ts.fixed_locks = nil
+		end
+		
 		if fields.reset then
 			-- User requested resetting the section
 			-- Show him what this means...
@@ -527,7 +652,7 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		ts.route = nil
 		for _, sigd in ipairs(ts.tc_breaks) do
 			local tcbs = ildb.get_tcbs(sigd)
-			advtrains.interlocking.update_signal_aspect(tcbs)
+			advtrains.interlocking.signal.update_route_aspect(tcbs)
 		end
 		minetest.chat_send_player(pname, attrans("Reset track section @1!", ts_id))
 	end
@@ -559,6 +684,13 @@ minetest.register_entity("advtrains_interlocking:tcbmarker", {
 	on_activate = function(self, sdata) if sdata=="STATIC" then self.object:remove() end end,
 })
 
+function advtrains.interlocking.remove_tcb_marker_pts(pts)
+	if markerent[pts] then
+		markerent[pts]:remove()
+		markerent[pts] = nil
+	end
+end
+
 function advtrains.interlocking.show_tcb_marker(pos)
 	--atdebug("showing tcb marker",pos)
 	local tcb = ildb.get_tcb(pos)
@@ -575,16 +707,14 @@ function advtrains.interlocking.show_tcb_marker(pos)
 			ts = ildb.get_ts(tcbs.ts_id)
 		end
 		if ts then
-			itex[connid] = ts.name
+			itex[connid] = ts.name or tcbs.ts_id or "???"
 		else
 			itex[connid] = "--EOI--"
 		end
 	end
 	
 	local pts = advtrains.roundfloorpts(pos)
-	if markerent[pts] then
-		markerent[pts]:remove()
-	end
+	advtrains.interlocking.remove_tcb_marker_pts(pts)
 	
 	local obj = minetest.add_entity(pos, "advtrains_interlocking:tcbmarker")
 	if not obj then return end
@@ -598,6 +728,88 @@ function advtrains.interlocking.show_tcb_marker(pos)
 	markerent[pts] = obj
 end
 
+function advtrains.interlocking.remove_tcb_marker(pos)
+	local pts = advtrains.roundfloorpts(pos)
+	if markerent[pts] then
+		markerent[pts]:remove()
+	end
+	markerent[pts] = nil
+end
+
+local ts_showparticles_callback = function(pos, connid, bconnid)
+	minetest.add_particle({
+		pos = pos,
+		velocity = {x=0, y=0, z=0},
+		acceleration = {x=0, y=0, z=0},
+		expirationtime = 10,
+		size = 7,
+		vertical = true,
+		texture = "at_il_ts_highlight_particle.png",
+		glow = 6,
+	})
+end
+
+-- Spawns particles to highlight the clicked track section
+-- TODO: Adapt behavior to not dumb-walk anymore
+function advtrains.interlocking.highlight_track_section(pos)
+	local all_tcbs = ildb.get_all_tcbs_adjacent(pos, nil, ts_showparticles_callback)
+	for _,sigd in ipairs(all_tcbs) do
+		advtrains.interlocking.show_tcb_marker(sigd.p)
+	end
+end
+
+-- checks that the given route is still valid (i.e. all its TCBs, sections and locks exist)
+-- returns true (ok) or false, reason (on issue)
+function advtrains.interlocking.check_route_valid(route, sigd)
+	-- this code is partially copy-pasted from routesetting.lua
+	-- we start at the tc designated by signal
+	local c_sigd = sigd
+	local i = 1
+	local c_tcbs, c_ts_id, c_ts, c_rseg
+	while c_sigd and i<=#route do
+		c_tcbs = ildb.get_tcbs(c_sigd)
+		if not c_tcbs then
+			return false, "No TCBS at "..sigd_to_string(c_sigd)
+		end
+		c_ts_id = c_tcbs.ts_id
+		if not c_ts_id then
+			return false, "No track section adjacent to "..sigd_to_string(c_sigd)
+		end
+		c_ts = ildb.get_ts(c_ts_id)
+		
+		c_rseg = route[i]
+		
+		if c_rseg.locks then
+			for pts, state in pairs(c_rseg.locks) do
+				local pos = advtrains.decode_pos(pts)
+				if not advtrains.is_passive(pos) then
+					return false, "No passive component for lock at "..pts
+				end
+			end
+		end
+		-- sanity check, is section at next the same as the current?
+		local nvar = c_rseg.next
+		if nvar then
+			local re_tcbs = ildb.get_tcbs({p = nvar.p, s = (nvar.s==1) and 2 or 1})
+			if not re_tcbs or not re_tcbs.ts_id or re_tcbs.ts_id~=c_ts_id then
+				return false, "TCB at "..minetest.pos_to_string(nvar.p).." has different section than previous TCB."
+			end
+		end
+		-- advance
+		c_sigd = nvar
+		i = i + 1
+	end
+	-- check end TCB
+	if not c_sigd then
+		return false, "Final TCBS unset (legacy-style buffer route)"
+	end
+	c_tcbs = ildb.get_tcbs(c_sigd)
+	if not c_tcbs then
+		return false, "Final TCBS missing at "..sigd_to_string(c_sigd)
+	end
+	return true, nil, c_sigd
+end
+
 -- Signalling formspec - set routes a.s.o
 
 -- textlist selection temporary storage
@@ -614,7 +826,6 @@ function advtrains.interlocking.show_signalling_form(sigd, pname, sel_rte, calle
 	local tcbs = ildb.get_tcbs(sigd)
 	
 	if not tcbs.signal then return end
-	if not tcbs.signal_name then tcbs.signal_name = "Signal at "..minetest.pos_to_string(sigd.p) end
 	if not tcbs.routes then tcbs.routes = {} end
 	
 	local form = "size[7,10]label[0.5,0.5;"..attrans("Signal at @1", minetest.pos_to_string(sigd.p)).."]"
@@ -649,42 +860,76 @@ function advtrains.interlocking.show_signalling_form(sigd, pname, sel_rte, calle
 		form = form.."button[0.5,6;  5,1;cancelroute;"..attrans("Cancel Route").."]"
 	else
 		if not tcbs.route_origin then
-			local strtab = {}
-			for idx, route in ipairs(tcbs.routes) do
-				local clr = ""
-				if route.ars then
-					clr = "#FF5555"
-					if route.ars.default then
-						clr = "#55FF55"
+			if #tcbs.routes > 0 then
+				-- at least one route is defined, show normal dialog
+				local strtab = {}
+				for idx, route in ipairs(tcbs.routes) do
+					local rname = route.name
+					local valid = atil.check_route_valid(route, sigd)
+					local clr = ""
+					if not valid then
+						clr = "#FF5555"
+						rname = rname.." (invalid)"
+					elseif route.ars then
+						clr = "#FFFF55"
+						if route.ars.default then
+							clr = "#55FF55"
+						end
+					end
+					strtab[#strtab+1] = clr .. minetest.formspec_escape(rname)
+				end
+				form = form.."label[0.5,2.5;Routes:]"
+				form = form.."textlist[0.5,3;5,3;rtelist;"..table.concat(strtab, ",")
+				if sel_rte then
+					form = form .. ";" .. sel_rte .."]"
+					form = form.."button[0.5,6;  5,1;setroute;Set Route]"
+					form = form.."button[0.5,7;2,1;dsproute;Show]"
+					if hasprivs then
+						form = form.."button[5.5,3.3;1,0.3;setarsdefault;D]tooltip[setarsdefault;Set ARS default route]"
+						form = form.."button[3.5,7;2,1;editroute;Edit]"
+						if sel_rte > 1 then
+							form = form .. "button[5.5,4;1,0.3;moveup;↑]"
+						end
+						if sel_rte < #strtab then
+							form = form .. "button[5.5,4.7;1,0.3;movedown;↓]"
+						end
+						form = form.."button[5.5,5.4;1,0.3;delroute;X]tooltip[delroute;Delete this route]"
+					end
+				else
+					form = form .. "]"
+					if tcbs.ars_disabled then
+						form = form.."label[0.5,6  ;NOTE: ARS is disabled.]"
+						form = form.."label[0.5,6.5;Routes are not automatically set.]"
 					end
 				end
-				strtab[#strtab+1] = clr .. minetest.formspec_escape(route.name)
-			end
-			form = form.."label[0.5,2.5;"..attrans("Routes:").."]"
-			form = form.."textlist[0.5,3;5,3;rtelist;"..table.concat(strtab, ",").."]"
-			if sel_rte then
-				form = form.."button[0.5,6;5,1;setroute;"..attrans("Set Route").."]"
-				form = form.."button[0.5,7;2,1;dsproute;"..attrans("Show").."]"
 				if hasprivs then
-					form = form.."button[3.5,7;2,1;editroute;"..attrans("Edit").."]"
-					-- form = form.."button[5.75,3;1,1;routeup;^]"
+					form = form.."button[0.5,8;2.5,1;smartroute;Smart Route]"
+					form = form.."button[  3,8;2.5,1;newroute;New (Manual)]"
+					form = form..string.format("checkbox[0.5,8.75;ars;Automatic routesetting;%s]", not tcbs.ars_disabled)
+					form = form..string.format("checkbox[0.5,9.25;dstarstrig;Distant signal triggers ARS;%s]", not tcbs.no_dst_ars_trig)
 				end
 			else
-				if tcbs.ars_disabled then
-					form = form.."label[0.5,6  ;"..attrans("NOTE: ARS is disabled.").."]"
-					form = form.."label[0.5,6.5;"..attrans("Routes are not automatically set.").."]"
+				-- no route is active, and no route is so far defined
+				if not tcbs.signal then atwarn("signalling form missing signal?!", pos) return end -- safeguard, nothing else in this function checks tcbs.signal
+				local caps = advtrains.interlocking.signal.get_signal_cap_level(tcbs.signal)
+				if caps >= 4 then
+					-- offer user the "block signal mode"
+					form = form.."label[0.5,2.5;No routes are yet defined.]"
+					if hasprivs then
+						form = form.."button[0.5,4;2.5,1;smartroute;Smart Route]"
+						form = form.."button[  3,4;2.5,1;newroute;New (Manual)]"
+					end
+				elseif caps >= 3 then
+					-- it's a buffer!
+					form = form.."label[0.5,2.5;This is an always-halt signal (e.g. a buffer)\n"
+								.."No routes can be set from here.]"
+				else
+					-- signal caps say it cannot be route start/end
+					form = form.."label[0.5,2.5;This is a pure distant signal\n"
+								.."No route is currently set through.]"
 				end
 			end
-			if hasprivs then
-				form = form.."button[0.5,8;2.5,1;newroute;"..attrans("New Route").."]"
-				form = form.."button[  3,8;2.5,1;unassign;"..attrans("Unassign Signal").."]"
-				form = form.."button[  3,9;2.5,1;influp;"..attrans("Influence Point").."]"
-			end
-			if tcbs.ars_disabled then
-				form = form.."button[0.5,9;2.5,1;arsenable;"..attrans("Enable ARS").."]"
-			else
-				form = form.."button[0.5,9;2.5,1;arsdisable;"..attrans("Disable ARS").."]"
-			end
+			
 		elseif sigd_equal(tcbs.route_origin, sigd) then
 			-- something has gone wrong: tcbs.routeset should have been set...
 			form = form.."label[0.5,2.5;"..attrans("Inconsistent state: route_origin is same TCBS but no route set. Try again.").."]"
@@ -701,14 +946,14 @@ function advtrains.interlocking.show_signalling_form(sigd, pname, sel_rte, calle
 	-- always a good idea to update the signal aspect
 	if not called_from_form_update then
 	-- FIX prevent a callback loop
-		advtrains.interlocking.update_signal_aspect(tcbs)
+		advtrains.interlocking.signal.update_route_aspect(tcbs)
 	end
 end
 
 function advtrains.interlocking.update_player_forms(sigd)
 	for pname, tsigd in pairs(p_open_sig_form) do
 		if advtrains.interlocking.sigd_equal(sigd, tsigd) then
-			advtrains.interlocking.show_signalling_form(sigd, pname, nil)
+			advtrains.interlocking.show_signalling_form(sigd, pname, nil, true)
 		end
 	end
 end
@@ -721,10 +966,7 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 	end
 	local hasprivs = minetest.check_player_privs(pname, "interlocking")
 	
-	-- independent of the formspec, clear this whenever some formspec event happens
 	local tpsi = sig_pselidx[pname]
-	sig_pselidx[pname] = nil
-	p_open_sig_form[pname] = nil
 	
 	local pts, connids = string.match(formname, "^at_il_signalling_([^_]+)_(%d)$")
 	local pos, connid
@@ -739,6 +981,8 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		if not tcbs then return end
 
 		if fields.quit then
+			sig_pselidx[pname] = nil
+			p_open_sig_form[pname] = nil
 			-- form quit: disable temporary ARS ignore
 			tcbs.ars_ignore_next = nil
 			return
@@ -747,12 +991,18 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		local sel_rte
 		if fields.rtelist then
 			local tev = minetest.explode_textlist_event(fields.rtelist)
-			sel_rte = tev.index
+			if tev.type ~= "INV" then
+				sel_rte = tev.index
+			end
 		elseif tpsi then
 			sel_rte = tpsi
 		end
 		if fields.setname and fields.name and hasprivs then
-			tcbs.signal_name = fields.name
+			if fields.name == "" then
+				tcbs.signal_name = nil -- do not save a signal name if it isnt used (equivalent to track sections)
+			else
+				tcbs.signal_name = fields.name
+			end
 		end
 		if tcbs.routeset and fields.cancelroute then
 			if tcbs.routes[tcbs.routeset] and tcbs.routes[tcbs.routeset].ars then
@@ -768,6 +1018,11 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 				tcbs.ars_ignore_next = nil
 				return
 			end
+			if fields.smartroute and hasprivs then
+				advtrains.interlocking.smartroute.start(pname, sigd)
+				tcbs.ars_ignore_next = nil
+				return
+			end
 			if sel_rte and tcbs.routes[sel_rte] then
 				if fields.setroute then
 					ilrs.update_route(sigd, tcbs, sel_rte)
@@ -779,41 +1034,45 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 				end
 				if fields.editroute and hasprivs then
 					advtrains.interlocking.show_route_edit_form(pname, sigd, sel_rte)
-					--local rte = tcbs.routes[sel_rte]
-					--minetest.show_formspec(pname, formname.."_renroute_"..sel_rte, "field[name;Enter new route name;"..rte.name.."]")
 					return
 				end
+				if fields.setarsdefault and hasprivs then
+					for rid, route in ipairs(tcbs.routes) do
+						local isdefault = rid == sel_rte
+						if route.ars then
+							if route.ars.default and isdefault then
+								-- D button pressed but route was already default - remove ars default field!
+								route.ars.default = nil
+							elseif isdefault then
+								route.ars.default = true
+							else
+								route.ars.default = nil
+							end
+							-- if the table is nouw empty delete it
+							if not next(route.ars) then
+								route.ars = nil
+							end
+						elseif isdefault then
+							route.ars = {default = true}
+						end
+					end
+				end
+				if fields.delroute and hasprivs then
+					if tcbs.routes[sel_rte] and tcbs.routes[sel_rte].ars then
+						minetest.chat_send_player(pname, "Cannot delete route which has ARS rules, please review and then delete through edit dialog!")
+					else
+						table.remove(tcbs.routes,sel_rte)
+					end
+				end
 			end
 		end
 		
-		if fields.unassign and hasprivs then
-			-- unassigning the signal from the tcbs
-			-- only when no route is set.
-			-- Routes and name remain saved, in case the player wants to reassign a new signal
-			if not tcbs.routeset then
-				local signal_pos = tcbs.signal
-				ildb.set_sigd_for_signal(signal_pos, nil)
-				tcbs.signal = nil
-				tcbs.aspect = nil
-				minetest.close_formspec(pname, formname)
-				minetest.chat_send_player(pname, attrans("Signal has been unassigned. Name and routes are kept for reuse."))
-				return
-			else
-				minetest.chat_send_player(pname, attrans("Please cancel route first!"))
-			end
-		end
-		if fields.influp and hasprivs then
-			advtrains.interlocking.show_ip_form(tcbs.signal, pname)
-			return
+		if fields.ars then
+			tcbs.ars_disabled = not minetest.is_yes(fields.ars)
 		end
 		
-		if tcbs.ars_disabled and fields.arsenable then
-			core.log("action", pname.." turn ARS on at "..pts)
-			tcbs.ars_disabled = nil
-		end
-		if not tcbs.ars_disabled and fields.arsdisable then
-			core.log("action", pname.." turn ARS off at "..pts)
-			tcbs.ars_disabled = true
+		if fields.dstarstrig then
+			tcbs.no_dst_ars_trig = not minetest.is_yes(fields.dstarstrig)
 		end
 		
 		if fields.auto then
@@ -822,28 +1081,22 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 		if fields.noauto then
 			tcbs.route_auto = false
 		end
+
+		if sel_rte and tcbs.routes[sel_rte]and not tcbs.routeset then
+			if fields.moveup then
+				if tcbs.routes[sel_rte - 1] then
+					tcbs.routes[sel_rte - 1], tcbs.routes[sel_rte] = tcbs.routes[sel_rte], tcbs.routes[sel_rte - 1]
+					sel_rte = sel_rte - 1
+				end
+			elseif fields.movedown then
+				if tcbs.routes[sel_rte + 1] then
+					tcbs.routes[sel_rte + 1], tcbs.routes[sel_rte] = tcbs.routes[sel_rte], tcbs.routes[sel_rte + 1]
+					sel_rte = sel_rte + 1
+				end
+			end
+		end
 		
 		advtrains.interlocking.show_signalling_form(sigd, pname, sel_rte, true)
 		return
 	end
-	
-	
-	if not hasprivs then return end
-	-- rename route
-	local rind, rte_id
-	pts, connids, rind = string.match(formname, "^at_il_signalling_([^_]+)_(%d)_renroute_(%d+)$")
-	if pts then
-		pos = minetest.string_to_pos(pts)
-		connid = tonumber(connids)
-		rte_id = tonumber(rind)
-		if not connid or connid<1 or connid>2 then return end
-	end
-	if pos and connid and rind and fields.name then
-		local sigd = {p=pos, s=connid}
-		local tcbs = ildb.get_tcbs(sigd)
-		if tcbs.routes[rte_id] then
-			tcbs.routes[rte_id].name = fields.name
-			advtrains.interlocking.show_signalling_form(sigd, pname)
-		end
-	end
 end)
diff --git a/advtrains_interlocking/textures/at_il_ts_highlight_particle.png b/advtrains_interlocking/textures/at_il_ts_highlight_particle.png
new file mode 100644
index 0000000..4ba3622
--- /dev/null
+++ b/advtrains_interlocking/textures/at_il_ts_highlight_particle.png
diff --git a/advtrains_interlocking/tool.lua b/advtrains_interlocking/tool.lua
index 82b295e..7ccab46 100644
--- a/advtrains_interlocking/tool.lua
+++ b/advtrains_interlocking/tool.lua
@@ -3,14 +3,78 @@
 
 local ilrs = advtrains.interlocking.route
 
+local function node_right_click(pos, pname, player)
+	if advtrains.is_passive(pos) then
+		local form = "size[7,5]label[0.5,0.5;Route lock inspector]"
+		local pts = advtrains.encode_pos(pos)
+		
+		local rtl = ilrs.has_route_lock(pts)
+		
+		if rtl then
+			form = form.."label[0.5,1;Route locks currently put:\n"..rtl.."]"
+			form = form.."button_exit[0.5,3.5;  5,1;clear;Clear]"
+		else
+			form = form.."label[0.5,1;No route locks set]"
+			form = form.."button_exit[0.5,3.5;  5,1;emplace;Emplace manual lock]"
+		end
+		
+		minetest.show_formspec(pname, "at_il_rtool_"..pts, form)
+		return
+	end
+
+	-- If not a turnout, check the track section and show a form
+	local node_ok, conns, rail_y=advtrains.get_rail_info_at(pos)
+	if not node_ok then
+		minetest.chat_send_player(pname, "Node is not a track!")
+		return
+	end
+	if advtrains.interlocking.db.get_tcb(pos) then
+		advtrains.interlocking.show_tcb_form(pos, pname)
+		return
+	end
+
+	local ts_id = advtrains.interlocking.db.check_and_repair_ts_at_pos(pos, nil, pname)
+	if ts_id then
+		advtrains.interlocking.show_ts_form(ts_id, pname)
+	else
+		minetest.chat_send_player(pname, "No track section at this location!")
+	end
+end
+
+local function node_left_click(pos, pname, player)
+	local node_ok, conns, rail_y=advtrains.get_rail_info_at(pos)
+	if not node_ok then
+		minetest.chat_send_player(pname, "Node is not a track!")
+		return
+	end
+
+	if advtrains.interlocking.db.get_tcb(pos) then
+		advtrains.interlocking.show_tcb_marker(pos)
+		return
+	end
+	
+	-- create track section if aux1 button down
+	local pc = player:get_player_control()
+	local force_create = pc.aux1
+
+	local ts_id = advtrains.interlocking.db.check_and_repair_ts_at_pos(pos, nil, pname, force_create)
+	if ts_id then
+		advtrains.interlocking.db.update_rs_cache(ts_id)
+		advtrains.interlocking.highlight_track_section(pos)
+	else
+		minetest.chat_send_player(pname, "No track section at this location!")
+	end
+end
+
+
 minetest.register_craftitem("advtrains_interlocking:tool",{
-	description = attrans("Interlocking tool\nright-click turnouts to inspect route locks"),
+	description = "Interlocking tool\nPunch: Highlight track section\nPlace: check route locks/show track section info",
 	groups = {cracky=1}, -- key=name, value=rating; rating=1..3.
 	inventory_image = "at_il_tool.png",
 	wield_image = "at_il_tool.png",
 	stack_max = 1,
-	on_place = function(itemstack, placer, pointed_thing)
-		local pname = placer:get_player_name()
+	on_place = function(itemstack, player, pointed_thing)
+		local pname = player:get_player_name()
 		if not pname then
 			return
 		end
@@ -20,36 +84,23 @@ minetest.register_craftitem("advtrains_interlocking:tool",{
 		end
 		if pointed_thing.type=="node" then
 			local pos=pointed_thing.under
-			if advtrains.is_passive(pos) then
-				local form = "size[7,5]label[0.5,0.5;" .. attrans("Route lock inspector") .. "]"
-				local pts = minetest.pos_to_string(pos)
-				
-				local rtl = ilrs.has_route_lock(pts)
-				
-				if rtl then
-					form = form.."label[0.5,1;" .. attrans("Route locks currently put:") .. "\n"..rtl.."]"
-					form = form.."button_exit[0.5,3.5;  5,1;clear;" .. attrans("Clear") .. "]"
-				else
-					form = form.."label[0.5,1;" .. attrans("No route locks set") .. "]"
-					form = form.."button_exit[0.5,3.5;  5,1;emplace;" .. attrans("Emplace manual lock") .. "]"
-				end
-				
-				minetest.show_formspec(pname, "at_il_rtool_"..pts, form)
-			else
-				minetest.chat_send_player(pname, attrans("Cannot use this here."))
-				return
-			end
+			node_right_click(pos, pname, player)
 		end
 	end,
-})
-
-minetest.register_craft({
-	output = "advtrains_interlocking:tool",
-	recipe = {
-		{"default:diamond", "", ""},
-		{"ch_extras:lupa", "", ""},
-		{"default:steel_ingot", "", ""},
-	},
+	on_use = function(itemstack, player, pointed_thing)
+		local pname = player:get_player_name()
+		if not pname then
+			return
+		end
+		if not minetest.check_player_privs(pname, {interlocking=true}) then
+			minetest.chat_send_player(pname, "Insufficient privileges to use this!")
+			return
+		end
+		if pointed_thing.type=="node" then
+			local pos=pointed_thing.under
+			node_left_click(pos, pname, player)
+		end
+	end
 })
 
 minetest.register_on_player_receive_fields(function(player, formname, fields)
@@ -60,7 +111,7 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 	local pos
 	local pts = string.match(formname, "^at_il_rtool_(.+)$")
 	if pts then
-		pos = minetest.string_to_pos(pts)
+		pos = advtrains.decode_pos(pts)
 	end
 	if pos then
 		if advtrains.is_passive(pos) then
diff --git a/advtrains_interlocking/train_sections.lua b/advtrains_interlocking/train_sections.lua
index 757f36a..a1ee87f 100644
--- a/advtrains_interlocking/train_sections.lua
+++ b/advtrains_interlocking/train_sections.lua
@@ -40,83 +40,99 @@ local function itkexist(tbl, ikey, com)
 	return false
 end
 
-local function itremove(tbl, com)
+local function itremove(tbl, com, once)
 	local i=1
 	while i <= #tbl do
 		if tbl[i] == com then
 			table.remove(tbl, i)
+			if once then return end
 		else
 			i = i + 1
 		end
 	end
 end
-local function itkremove(tbl, ikey, com)
+local function itkremove(tbl, ikey, com, once)
 	local i=1
 	while i <= #tbl do
 		if tbl[i][ikey] == com then
 			table.remove(tbl, i)
+			if once then return end
 		else
 			i = i + 1
 		end
 	end
 end
 
-local function setsection(tid, train, ts_id, ts, sigd)
+local function setsection(tid, train, ts_id, ts, sigd, only_if_not_exist)
 	-- train
 	if not train.il_sections then train.il_sections = {} end
-	if not itkexist(train.il_sections, "ts_id", ts_id) then
+	if only_if_not_exist then
+		-- called for the back connid on enter, only to ensure that section is blocked if train was so far not registered
+		if not itkexist(train.il_sections, "ts_id", ts_id) then
+			table.insert(train.il_sections, {ts_id = ts_id, origin = sigd})
+		end
+	else
+		-- insert always, this leads to duplicate entries if the train enters the same section a second time
 		table.insert(train.il_sections, {ts_id = ts_id, origin = sigd})
 	end
 	
 	-- ts
 	if not ts.trains then ts.trains = {} end
-	if not itexist(ts.trains, tid) then
+	if only_if_not_exist then
+		-- called for the back connid on enter, only to ensure that section is blocked if train was so far not registered
+		if not itexist(ts.trains, tid) then
+			table.insert(ts.trains, tid)
+		end
+	else
 		table.insert(ts.trains, tid)
 	end
 	
 	-- routes
-	local tcbs = advtrains.interlocking.db.get_tcbs(sigd)
+	local tcbs
+	if sigd then
+		tcbs = advtrains.interlocking.db.get_tcbs(sigd)
+	end
 	
 	-- route setting - clear route state
 	if ts.route then
 		--atdebug(tid,"enters",ts_id,"examining Routestate",ts.route)
-		if not sigd_equal(ts.route.entry, sigd) then
+		if sigd and not sigd_equal(ts.route.entry, sigd) then
 			-- Train entered not from the route. Locate origin and cancel route!
 			atwarn("Train",tid,"hit route",ts.route.rsn,"!")
 			advtrains.interlocking.route.cancel_route_from(ts.route.origin)
 			atwarn("Route was cancelled.")
 		else
-			-- train entered route regularily. Reset route and signal
-			tcbs.route_committed = nil
-			tcbs.route_comitted = nil -- TODO compatibility cleanup
-			tcbs.aspect = nil
-			tcbs.route_origin = nil
-			advtrains.interlocking.update_signal_aspect(tcbs)
-			if tcbs.signal and sigd_equal(ts.route.entry, ts.route.origin) then
-				if tcbs.route_auto and tcbs.routeset then
-					--atdebug("Resetting route (",ts.route.origin,")")
-					advtrains.interlocking.route.update_route(ts.route.origin, tcbs)
-				else
-					tcbs.routeset = nil
-				end
-			end
+			-- train entered route regularily.
 		end
 		ts.route = nil
 	end
-	if tcbs.signal then
+	if tcbs and tcbs.signal then
+		-- Reset route and signal
+		-- Note that the hit-route case is already handled by cancel_route_from
+		-- this code only handles signal at entering tcb and also triggers for non-route ts
+		tcbs.route_committed = nil
+		tcbs.route_aspect = nil
+		tcbs.route_remote = nil
+		tcbs.route_origin = nil
+		tcbs.route_rsn = nil
+		if not tcbs.route_auto then
+			tcbs.routeset = nil
+		end
+		advtrains.interlocking.signal.update_route_aspect(tcbs)
 		advtrains.interlocking.route.update_route(sigd, tcbs)
 	end
 end
 
-local function freesection(tid, train, ts_id, ts)
+local function freesection(tid, train, ts_id, ts, clear_all)
 	-- train
 	if not train.il_sections then train.il_sections = {} end
-	itkremove(train.il_sections, "ts_id", ts_id)
+	itkremove(train.il_sections, "ts_id", ts_id, not clear_all)
 	
 	-- ts
 	if not ts.trains then ts.trains = {} end
-	itremove(ts.trains, tid)
+	itremove(ts.trains, tid, not clear_all)
 	
+	-- route locks
 	if ts.route_post then
 		advtrains.interlocking.route.free_route_locks(ts_id, ts.route_post.locks)
 		if ts.route_post.next then
@@ -138,12 +154,18 @@ end
 -- This sets the section for both directions, to be failsafe
 advtrains.tnc_register_on_enter(function(pos, id, train, index)
 	local tcb = ildb.get_tcb(pos)
-	if tcb then
-		for connid=1,2 do
-			local ts = tcb[connid].ts_id and ildb.get_ts(tcb[connid].ts_id)
-			if ts then
-				setsection(id, train, tcb[connid].ts_id, ts, {p=pos, s=connid})
-			end
+	if tcb and train.path_cp[index] and train.path_cn[index] then
+		-- forward conn
+		local connid = train.path_cn[index]
+		local ts = tcb[connid] and tcb[connid].ts_id and ildb.get_ts(tcb[connid].ts_id)
+		if ts then
+			setsection(id, train, tcb[connid].ts_id, ts, {p=pos, s=connid})
+		end
+		-- backward conn (safety only)
+		connid = train.path_cp[index]
+		ts = tcb[connid] and tcb[connid].ts_id and ildb.get_ts(tcb[connid].ts_id)
+		if ts then
+			setsection(id, train, tcb[connid].ts_id, ts, {p=pos, s=connid}, true)
 		end
 	end
 end)
@@ -153,8 +175,9 @@ end)
 advtrains.tnc_register_on_leave(function(pos, id, train, index)
 	local tcb = ildb.get_tcb(pos)
 	if tcb and train.path_cp[index] then
+		-- backward conn
 		local connid = train.path_cp[index]
-		local ts = tcb[connid].ts_id and ildb.get_ts(tcb[connid].ts_id)
+		local ts = tcb[connid] and tcb[connid].ts_id and ildb.get_ts(tcb[connid].ts_id)
 		if ts then
 			freesection(id, train, tcb[connid].ts_id, ts)
 		end
@@ -167,13 +190,13 @@ advtrains.te_register_on_create(function(id, train)
 	-- let's see what track sections we find here
 	local index = atround(train.index)
 	local pos = advtrains.path_get(train, index)
-	local ts_id, origin = ildb.get_ts_at_pos(pos)
+	local ts_id = ildb.check_and_repair_ts_at_pos(pos, 1) -- passing connid 1 - that always exists
 	if ts_id then
 		local ts = ildb.get_ts(ts_id)
 		if ts then
-			setsection(id, train, ts_id, ts, origin)
+			setsection(id, train, ts_id, ts, nil, true)
 		else
-			atwarn("ILDB corruption: TCB",origin," has invalid TS reference")
+			atwarn("While placing train, TS didnt exist ",ts_id)
 		end
 		-- Make train a shunt move
 		train.is_shunt = true
diff --git a/advtrains_interlocking/tsr_rail.lua b/advtrains_interlocking/tsr_rail.lua
index 7ad6a7a..9fdc3d9 100644
--- a/advtrains_interlocking/tsr_rail.lua
+++ b/advtrains_interlocking/tsr_rail.lua
@@ -3,13 +3,15 @@
 -- Simple rail whose only purpose is to place a TSR on the position, as a temporary solution until the timetable system covers everything.
 -- This code resembles the code in lines/stoprail.lua
 
+local S = attrans
+
 local function updateform(pos)
 	local meta = minetest.get_meta(pos)
 	local pe = advtrains.encode_pos(pos)
 	local npr = advtrains.interlocking.npr_rails[pe] or 2
 	
-	meta:set_string("infotext", attrans("Point speed restriction") .. ": "..npr)
-	meta:set_string("formspec", "field[npr;"..attrans("Set point speed restriction:")..";"..npr.."]")
+	meta:set_string("infotext", S("Point speed restriction: @1",npr))
+	meta:set_string("formspec", "field[npr;"..S("Set point speed restriction:")..";"..npr.."]")
 end
 
 
@@ -25,11 +27,11 @@ local adefunc = function(def, preset, suffix, rotation)
 			on_receive_fields = function(pos, formname, fields, player)
 				local pname = player:get_player_name()
 				if not minetest.check_player_privs(pname, {interlocking=true}) then
-					minetest.chat_send_player(pname, attrans("Interlocking privilege required!"))
+					minetest.chat_send_player(pname, S("You are not allowed to configure this track without the @1 privilege.", "interlocking"))
 					return
 				end
 				if minetest.is_protected(pos, pname) then
-					minetest.chat_send_player(pname, attrans("This rail is protected!"))
+					minetest.chat_send_player(pname, S("You are not allowed to configure this track."))
 					minetest.record_protection_violation(pos, pname)
 					return
 				end
@@ -59,7 +61,7 @@ if minetest.get_modpath("advtrains_train_track") ~= nil then
 		models_prefix="advtrains_dtrack",
 		models_suffix=".b3d",
 		shared_texture="advtrains_dtrack_shared_npr.png",
-		description=attrans("Point Speed Restriction Rail"),
+		description=S("Point Speed Restriction Track"),
 		formats={},
 		get_additional_definiton = adefunc,
 	}, advtrains.trackpresets.t_30deg_straightonly)