【Factorio】Placement Rules for Chain Signals

The chain train signal, also known as a chain signal, may look intimidating at first, but the placement criteria are actually quite straightforward. For beginners to intermediate players building intersections in Factorio 2.0 vanilla or Space Age, you can avoid most mistakes by sticking to just three principles: use chain signals at entrances, standard signals only where it's safe for trains to stop after exiting, and chain signals again for exits leading to short consecutive intersections. These three rules will keep you from going far wrong.

I myself got stuck on my first T-junction, with trains constantly stopping inside the intersection asking "why does this jam up?" But the moment I switched the entrance to a chain signal and created enough space after the intersection for the full train length, the flow stabilized dramatically.

This article walks through these three principles with practical examples, showing where to place signals to avoid congestion.

The Three Rules for Placing Chain Signals in Factorio

To put it simply, the most practical way to remember chain train signals is: "place them before entering intersections," and standard signals as "place them after exiting intersections, but only where it's okay to stop." After organizing my thinking this way, I've stopped second-guessing myself on T-junctions and larger intersections. Reference: The official explanation for chain train signals (Factorio Wiki) is being consulted, but wiki pages are updated regularly, so please verify the current content and URL before publication. https://wiki.factorio.com/Rail_chain_signal/

Principle 1: Chain Signals at Entrances

At the entrance of branches, merges, and intersections, start with chain signals. This is the most critical of the three principles. The reason is simple: we want trains to judge "can I complete this crossing?" before entering, not "let me figure it out once I'm inside."

If you put a standard signal at the entrance, the train only looks at whether the block immediately after it is free. This tempts trains to push their way in, only to get stuck partway through the intersection while waiting, which then jams up both parallel and perpendicular traffic. Bluntly, this is the rookie mistake I see most often. I spent a lot of time frustrated about "I placed signals but still have gridlock," but switching the entrance to a chain signal alone cut intersection-blocking incidents dramatically.

A chain signal looks ahead to the next signal to decide whether to enter. If the intersection's exit is blocked, it keeps trains waiting at the entrance. In other words, it prevents the intersection itself from becoming a waiting area. Whether it's a branch, merge, or crossing, the basic rule is the same: always look ahead before entering a place where routes can conflict.

If you can place signals inside the intersection, it's standard practice to link internal blocks with chain signals as well. This lets non-crossing routes be separated and flow more independently, which stabilizes throughput during congestion. The benefit shows up especially clearly in two-track cross-junctions or intersections where left/right turns mix.

Principle 2: Standard Signals Only Where Trains Can Stop Safely

The key to placing standard signals is this: put them only in places where "a train can stop here without blocking the overall network." In other words, use standard signals to define stopping positions.

The typical case is a long straight section after an intersection where stopped trains won't interfere with branches or intersection areas behind them. Place a standard signal there, and trains will stop after clearing the intersection. This is why it's called "exit uses standard signal," though the precise statement is "use a standard signal at the exit if there's enough stopping space after it."

Conversely, place a standard signal in a place where trains shouldn't stop, and that signal becomes an official waiting point. The train seems to clear the intersection but actually its rear still occupies the crossing, blocking follow-up traffic. Deadlock causes look complicated, but a large share stem from "standard signal placed where trains shouldn't stop."

This principle becomes really important once traffic volumes rise beyond single junctions. As train count increases, where you let them wait directly impacts throughput. Standard signals are convenient, but placing one is essentially declaring "this is where trains can wait." Keeping that mindset cuts placement errors significantly.

Principle 3: Chain Signals for Consecutive Intersections or Short Blocks

"Use standard at exits" is the base rule, but it's not always the right answer. If the space after an intersection is short or the next intersection/branch/signal comes immediately, it's more stable to link the exit with a chain signal too.

The issue here is that placing a standard signal at the exit makes trains "count as having cleared the intersection" and keep moving. But if the following space is too short for the full train length, part of the train actually stays in the previous intersection. It looks clear but isn't, and that becomes a congestion hotspot.

Consecutive T-junctions or junctions with merges right after them see this problem constantly. I built a dense approach to a station once, placed a standard signal at the exit, and watched trains stop at an in-between position, slowing the entire network. In such places, using a chain signal at the exit too—to "let the signal assess all the way to the next safe stopping point"—flows much cleaner.

In short, you need chain signals in two situations: first, when the space outside the intersection can't hold the longest consist, and second, when the next decision point comes immediately after. The first prevents intersection overflow; the second keeps you from trying to hold too much space in one block.

Community practice often treats continuous-intersection exits as exceptions to "standard at exit," and this understanding-based approach beats rote memorization for real-world use. Link entrances, internals, and short exits with chain signals; switch to standard only where you have real waiting room. This flow prevents breakdown even in large networks.

Background: Standard vs. Chain Signal Differences

Terminology: Blocks and Reservation Logic

Getting this straight first makes standard and chain signal use much clearer. We're talking about Factorio 2.0 vanilla, and the same logic applies in Space Age. 2.0 and Space Age rolled out together per the Upcoming features - Factorio Wiki guidelines, and the signal principles covered here work in that scope.

Train signals divide tracks into blocks (sections), controlling whether a train may enter a given block. A block is the area between two signals or a section that includes a branch or crossing, and once a train occupies a block, another generally cannot. The reservation here is the idea of a train claiming its route in advance. I started thinking of signals as just "red means stop, green means go," but I later realized that skipping the reservation concept was why my busy intersections jammed so easily.

Standard signals mainly check whether the next block is free. Chain signals, by contrast, look far ahead down the track to see if the route stays clear through the next signal before permitting entry. The Factorio Wiki's tutorial on train signals (Signals - Factorio Wiki) treats chain signals as essential for managing intersection approach. In one sentence: standard signals check "can I enter the next block," while chain signals check "will I stay safe through the next signal ahead?"

Space Age

wiki.factorio.com

Judgment Logic: Standard vs. Chain

Standard signals excel at the entrance of "sections where it's okay to stop." They let trains in if the next block is free, making them good for straight sections or depot queues. But placing them at intersection entrances is a trap. Any space inside the intersection tempts trains to nose in; if what follows is busy, they stop inside. That's the root cause of entrance-standard-signal gridlock.

Chain signals are the opposite, judging entry very carefully. They look beyond the next block: do I have a clear route all the way to the next signal? If not, they make trains wait at the entrance. In other words, they prevent the intersection interior from becoming a waiting area. Understanding this shows why "chain at entrance, standard at exit" is fundamental: entrance decides whether to enter; exit marks where to stop.

The failure case is vivid. Entrance with a standard signal: train nose slides in, exit space is too short, train stops in the middle. Follow-up can't use the intersection, cross-traffic can't move, everything jams fast. I was seriously confused the first time—"I added a signal and things got worse?" That's because I wasn't thinking about which areas become waiting zones.

In intersections, think of this as bulk reservation. A chain signal says "enter only if you can claim all the way to the safe stopping point beyond." That stops mid-intersection standstills. Of course, with continuous junctions, simply swapping the exit to standard "unlocks" that short space as a waiting zone. That's why making the exit chain too becomes attractive—to push the judgment out to the next safe area.

Color Display (Blue/Red/Green) and Waiting Before the Intersection

Colors, too, make more sense when read as outcomes of how much reservation succeeded, not just "go/stop." Standard signals are basically green to proceed, red to stop. Chain signals introduce blue, which trips up newcomers. Blue roughly means there is a route ahead, but proceeding comes with conditions on that route. When you see blue around intersections, think "looking ahead while proceeding." This framing cuts confusion.

In intersection design, something more important than color is the idea of waiting before the intersection. Don't stop trains inside; make them wait outside. This alone changes network stability noticeably. Diagrammatically:

Standard signal at entrance
→ next intersection block is free, so enter
→ but exit is jammed, so stop inside

   [Std]
----S------X****intersection****X---[jammed]
             ↑
           stop here

Chain signal at entrance
→ check clear through intersection exit
→ if exit is jammed, wait outside

   [Chain]
----C------X****intersection****X---[jammed]
      ↑
   wait here

This "wait outside" design pairs with bulk reservation. Interior for throughput, exterior for waiting. In shared networks, following this rule alone cuts problems drastically. Unglamorous as it sounds, violating this is why even fancy intersections jam quickly.

For a basics-focused tutorial, the official Wiki's Signals guide is solid, and community examples like factorio@jp Wiki layout samples are very visual. When you start seeing intersections as "places where entry conditions must align to move a train through together" rather than "a corridor to pass through," standard and chain signal separation becomes intuitive.

Principle 1: Chain Signals at Branch/Merge/Intersection Entrances

This principle is the hardest to get wrong in chain signal placement. Put chain signals before branching, merging, or crossing. Locking this in cuts placement confusion dramatically. The logic is simple: with chain signals, "even if the immediate next space is free, if the exit is jammed, I won't enter." In other words, don't use intersection interiors as waiting areas.

Honestly, my first instinct was "if the entrance shows green, why can't I go?" But standard signals make trains ignore what lies ahead; they poke in, and if the far exit is blocked, they stop mid-intersection. One stuck train draws in sideways and turning traffic, and a single intersection mistake becomes a network-wide standstill chain. Swap the entrance to chain, and behavior changes: trains wait in blue at the entrance, then blaze through in green once conditions align. That switch is very visible in the moment—flow suddenly feels orderly.

Per the Chain signal - Factorio Wiki explanation, chain signals manage entry with route conditions attached. Thinking of intersections as "reserve through-passage all the way to safety before entering" keeps placement clean.

T-Junctions: Where to Place Chain Signals at Entrances

T-junctions make this rule quite intuitive. A T has a main line passing through and a branch merging/splitting. Place chain signals at every entrance that could touch the crossing—that is, main-line approach to crossing, and branch approach to crossing. Never give trains the chance to stop mid-intersection.

T-junction image:

        branch
         |
        [C]
         |
==******crossing*****==
   [C]           [exit side]
main→

The mindset: "judge entry to the T-block before actually entering." Chain signals mean trains don't reserve just the crossing itself, but the exit and beyond, then only enter if safe. If the exit is full, they wait outside. Standard signals would let them in because the crossing's first block is free, tempting them to turn mid-stuck. This is exactly the failure I saw: main traffic enters, branch exits get backed up, train stops inside, branch traffic can't move, both freeze.

Bad examples are very clear on a T. Main-line train with standard entrance signal enters the crossing; merge exit is jammed; train stops inside. Now branch-to-main traffic can't move. Follow-ups jam everywhere. I watched this happen a lot, but flipping the entrance to chain made "trains waiting in the intersection" vanish, and congestion behavior completely changed.

Cross-Junctions: Why All Entrances Need Chain Signals

This principle becomes critical at cross-junctions. More route combinations mean any mix of entrance standard signals makes mid-intersection stops likely to skyrocket. Cross-junctions involve north/south/east/west all meeting, so place chain signals at every entrance as baseline.

Cross-junction image:

        [C]
         |
==****crossing****==
[C]              [C]
         |
        [C]

Why all four? Because a cross isn't "I only need my route free." Say an east-west through train with standard entrance enters mid-crossing and stops—now north-south through and west-to-south turns all lock up. One train stopped inside claims rights in multiple directions. This is the cascade that makes single-junction mistakes into network collapses.

Chain signals at all entrances reframe the crossing as "enter only when clear to exit together," not "enter and figure it out." The visual difference is striking: trains line up outside, and the moment a route opens, the suitable train shoots through. With standard-entrance, trains shoehorn their way in; switching to chain moves that to waiting-outside behavior, and the flow improvement is tangible.

The Signals - Factorio Wiki tutorial also centers on using chain-side condition checking for intersection management. Cross-junctions are the textbook case for that principle.

Y-Branches and Merges: Chain Before Branching/Before Merge

Y-shapes look gentle and are easy to overlook, but they do the same job. Before a branch point or just before two lines become one, place chain signals.

Y-branch

      ↗ exit A
---[C]<
      ↘ exit B

Y-merge

inlet A ↘
         >[C]--- post-merge
inlet B ↗

Chain before a branch keeps trains from entering if their chosen exit is jammed. Standard here would let them push to the branch point and stop, blocking the other branch's departures. Y-shapes don't look as serious as cross-junctions, making "a little stop inside should be fine" seem reasonable—but they jam quite readily.

Merges are the same: if the merged line isn't clear and you let one inlet in, it stops with its nose in, freezing the other side. On main-to-branch merges especially, a single branch train stopping inside throttles main-line speed, so the impact is deceptively large. I've set up standard-signal merges where trains "just pop in a little and block everyone"—that partial-entry disappears with chain signals.

Personal blog posts like "Factorio Rail Building from Zero (Chain Signals)" and factorio@jp Wiki organize this clearly. Y-branches are just intersections in disguise; place chain before branching and before merging—keep placement consistent across T, cross, and Y.

Principle 2: Standard Signals Only Where Safe Stopping Exists

Fitting the Longest Consist

Here, "it's okay to use standard at the exit" does not mean "automatically standard because it's an exit." The requirement is singular: the exit-side stopping area must completely hold the longest consist in your network. Fudging this will let mid-intersection stops slip through, even with chain entrances.

How to think about the longest consist is quite practical: measure from locomotive front to last car rear. Not your typical trains, but the longest you actually use. Two-four trains? Standard. But if supply trains are longer, measure those. The post-intersection waiting space must fit the full longest train and still leave clearance around the signal.

Estimating by eye is riskier than measuring. Stop a long consist somewhere and count tiles from head to tail; that guides intersection design. I learned the hard way guessing "should fit"—only to watch the last car dangle in the crossing. Even slightly hanging back counts as blocking the intersection.

Personal blog examples point this out: standard-exit relies on exit space beforehand. Beginners often memorize "chain at entrance, standard at exit," but the precise rule is **chain at entrance, standard at exit *only if stopping room exists***. This conditional framing keeps judgment sound in irregular splits.

Exit Standard-Signal Eligibility Checklist

Wondering whether to make an exit standard? There's one thing to check: can a stopped train clear the intersection without poking into it? If yes, standard works; if no, keep the exit chain-linked for safety.

Decision sequence:

1. After the intersection exit, is there any block where trains might stop?
2. Does your longest consist fit entirely in that block?
3. Even fitted, does the rear clear the intersection zone?

Meet all three, and standard at exit works. The stopping position stays outside the crossing, so following and cross-direction traffic are unaffected. Fail any test, and standard at exit means "trains seem to clear but actually block the crossing."

This framing aligns with Chain signal - Factorio Wiki and community layouts. Judge by whether the block is a valid stopping zone rather than the signal name, keeping decisions consistent on T's, cross-junctions, or anything else.

Chain Signal - Factorio Wiki

wiki.factorio.com

Short Exit Problems and Fixes

The worst case with short exits is trains clearing the intersection but landing mid-intersection due to length. This doesn't just slow that one train—subsequent trains also can't use the intersection, and perpendicular traffic grinds to a halt. In a cross-junction that means multiple directions; even T-junctions affect both main and branch.

I hit this running four-car consists. Exit side looked right, but the waiting space afterward was too short, so trains stopped partway through the crossing. Small as that overhang was, operationally it was a full blockage, follow-ups jammed, alternate routes stalled, and apparent flow degraded far more than the symptom suggested. I swapped the exit from standard to chain, added proper waiting room, and suddenly everything stabilized.

The bad pattern: create just a short single-block space after the intersection, cut it with standard signal. Looks like "exit zone," but you've really made intersection innards a waiting area. Better practice: extend the waiting space enough for a full consist to stand comfortably, or build a separate stacker away from the intersection for overflow. Per the "Rail Network / Layout Examples - factorio@jp Wiki" reference, intersection throughput depends not just on the crossing itself but how much waiting room you carve off adjacent sections.

Short exits with standard signals really boil down to declaring a non-waiting place a valid stop. Realizing this makes solutions obvious: either don't use standard at short exits, or build enough external waiting so the intersection isn't the holding area. When flow stability breaks down despite good entrance chains, the post-intersection exits are usually the culprit.

Rail Network / Layout Examples - factorio@jp Wiki*

factorio@jp Wiki*

wikiwiki.jp

Principle 3: Chain Signals for Consecutive Intersections and Short Blocks

Consecutive Intersections: When Exit Goes Chain Too

The point that confuses newcomers most is when the first intersection's exit leads immediately to the next signal or next intersection. Reading principle two alone suggests "exit is exit, so standard is fine," but short-block chains jam quite a bit.

Reason: exiting one intersection doesn't guarantee the train clears if it stops soon after. Worse, in consecutive junctions you can't just look one step ahead; you need to see "is it safe all the way through the next intersection" or even the one after. You can appear to advance locally while the network overall deadlocks.

I built dense consecutive intersections once; the layout looked advancing locally while everything froze. The cause wasn't entrance placement but that I'd put standard at the first exit. Trains entering the second intersection then stalled just before it, turning the inter-intersection space into a wait zone—a huge efficiency loss. Linking that exit as chain and running the condition all the way to the next real waiting space let everything flow much cleaner.

The correction: treat the exit not as a standalone exit but together with the control point ahead. If the next signal or crossing is close, make the prior exit chain too, so trains don't commit halfway.

Long runs of merges and branches in tight spacing really benefit from this. Early standard signal placement tempts you to push trains forward often, but short blocks make that fine advance become a jam source. Chain-exiting consecutive intersections isn't stalling—it's keeping trains from entering zones they can't fully occupy.

One more thing that old guides might miss: intersectioninternal block splits. Community practice reports that 2.0+ benefits from internal subdivision in certain layouts, but before adopting verify the spec basis (patch notes or official Wiki). The concept looks like:

No split
[entrance chain] → [intersection = one block] → [exit]

Split:
[entrance chain] → [internal A] → [internal B] → [exit]
                    \__non-crossing routes use different blocks__/

When this splitting works, zones that previously meant "one train enters, everyone stops" become "conflicting trains wait, non-crossing paths flow independently." That dense crossing I untangled earlier worked exactly this way. Empty alongside full? Keeping them in one block froze both. Divide the interior so non-crossing routes have separate reservations—and suddenly they run in parallel. Understated change, huge flow difference.

The split is only useful where you have independent routes afterward. Splitting where all routes converge anyway just tangles the signal logic. So think of internal subdivision as separating non-intersecting flows rather than "tiny-cutting the intersection." This focus makes the value clear.

Guides like "Factorio Rail from Zero" and factorio@jp Wiki layout samples show this clearly. Viewing not just entrance-and-exit but where splitting the interior divides flow teaches the deeper signal idea.

Independent Route Parallel Running Through Internal Subdivision

The core of internal subdivision is **factoring route geometry in before signal placement**, not after. Skip this and you're trying to split a grid that's too cramped, lacking the room to put signals where they'd help—and reverting to one big block. This bit me early on, forcing line rewire.

Design tip: don't stare at intersection center only. Give room after branch or after crossing to drop a followup chain signal. Cramming curves tight to achieve "compact" wastes the chance for non-crossing parallelism.

Practical mindset:

1. Identify which routes truly cross and which don't, line-by-line
2. Mark boundaries of non-crossing zones, leaving signal placement space
3. The result: only non-competing routes merge into one block

This order prevents retrofitting for reasons—you're designing for intent. Especially in multiplayer or large networks, clarity matters. Oversplit intersections confuse visitors and cause accidents. Split only enough that "this separate route runs in parallel" is obvious.

The goal visually:

Bad:
route A ──┐
          ├─ whole intersection = one block
route B ──┘
→ one entering = other waits, even non-crossing combos

Good:
route A ──[internal 1]──┐
                         ├─[internal 2]
route B ──────────────┘
→ non-crossing sections split, parallel ready

This design shows most in continuous junctions and tight blocks. Even with clean entrance/exit chains, if the interior is "everyone shares," gridlock sneaks in. Splitting right removes that common hogging and makes flow "wait where necessary, flow where safe."

Layout Examples: T-Junctions, Cross-Junctions, Consecutive Intersections

T-Junction: Basic Chain-Entry/Standard-Exit Pattern

T-junctions are excellent teaching layouts—the chain-entry/standard-exit fundamentals are very visible. When I finally understood "chain prevents mid-crossing stops, standard marks safe exit zones," T-junctions clicked.

First, the rookie mistake layout—standard entrance—looks simple but jams often:

Bad example:
      S
      |
---- S+---- S
      |
      S

C=chain, S=standard

Trains here check only "is the next block free," not "can I fully clear." So merging or turning trains halt inside mid-crossing. T-junctions don't look too complex, but main-and-branch crossing the center means mid-floor stoppage cascades fast. I recall the puzzle being "why doesn't one signal stop this?" but the answer was entrance traffic rushing in.

Fixed layout swaps entrance to chain:

Better:
      C
      |
---- C+---- S
      |
      S

Thinking: chain at entrances, standard where trains can rest without blocking. T's stabilize immediately. Swapping back to bad form shows mid-crossing stops resuming; the difference is stark and immediate.

But T-junctions have exceptions too. If the exit leads immediately to another signal or crossing:

Bad: exit too short
      C
      |
---- C+---- S -- C+--
      |
      S

Right side's next crossing is close, S has no real wait space

Flow breaks because exiting trains claim the short zone and halt at the next crossing, which backs up into the T's exit. Seeming-exit becomes actual occupancy.

Better: extend exit as chain to look ahead:

Better: exit is chain too
      C
      |
---- C+---- C -- C+-- S
      |
      S

Now exiting trains see "can I reach the far true stop?" Entrance sees the condition; only proceeds if the answer is yes. T-basics here teach the exception—short exits need chain extension. This alone cuts "right layout, still jams" incidents for learners significantly.

Cross-Junctions: Parallel Independent Routes Via Internal Split

A common cross-junction error is all-entrance-chain placement but interior as one block. Safe yes, but throughput drops. Non-crossing pairs still wait serially.

Bad pattern:

Bad: internal = one block
        C
        |
--------[crossing whole]--------
        |
        C
      exit is S

C=chain, S=standard, [ ]=block boundary

One train entering blocks even non-competitive routes. Cross-junctions have more route combos, so lumping non-intersecting paths into the same block is expensive. As trains multiply, this becomes the gridlock spine.

Better: split interior blocks. 2.0 makes this quite approachable:

Better: internal split
          C
          |
------[A]---[B]------
          |
          C
      exit is S

[A] and [B] separate blocks

More route-aware subdivision:

        north
        C
        |
west C--[A]--[B]--C east
        |
        C
        south

Example:
north↔south, east↔west compete
north↔east, south↔west compete  
but layout can isolate non-crossing pairs in [A] vs [B]

The key is not "cut small" but "give non-crossing routes separate territory." If split interiors still need the same center point, the gain is slim. But with bends and space, splitting diverts pressure, and throughput grows visibly.

Demonstrating: I'll turn off interior signals, reverting to "whole block," which tanks throughput. Revert to the split layout—unconnected routes suddenly run in parallel. The shift is subtle visually, but flow-wise it's night-and-day.

Solid foundational understanding comes from Signals - Factorio Wiki tutorial, which prioritizes approach control. Cross-junctions plus interior sub-blocking extends that concept.

Consecutive Intersections: Exit Chain for "Look Two Steps Ahead"

Consecutive intersections often puzzle newcomers—apparent advancement hides gridlock. Single-intersection reading hints "use standard at exits," but tight spacing breaks that.

Bad form—first intersection exit is standard:

Bad: A exit is standard
---- C + A + S ---- C + B + S ----

Short A-B gap; S-stop blocks A rear for follow-ups

Jam reason: exit train enters short gap, B stop freezes it; A is still occupied for next trains. One hold cascades into two intersection blocks. I've sunk hours on this pattern. Map view: "looks like A is free." Operations: "A is frozen."

Better: A exit is chain, checking B's readiness:

Better: A exit is chain
---- C + A + C ---- C + B + S ----

Entry trains assess "can I clear through B too?" Only proceeds if yes. That's "next steps count, wait only after I've cleared them" logic. Consecutive intersection chains are as foundational as entrance chains.

Cutting further: intermediate blocks might split if non-crossing flows exist, letting parallel movement between A and B:

Even better: internals split
---- C + A + [gap1] C [gap2] + B + S ----

2.0 internal splitting shines here. "Whole A-to-B" serializes everything. Split the middle, and non-crossing pairs run alongside. Again, not routine chopping but separating actual flow paths.

Before/after is vivid: bad form, next-waiting trains pile outside A. Better form, waiting moves outside the block-pair. Consecutive junctions are really "where do trains wait"—exit handling is nearly as critical as entrance.

Common Failures and Fixes

Mid-Intersection Stops: Standard Entrance or Short Exit

When trains halt inside intersections, two causes dominate: entrance is standard or post-intersection waiting room is too small. Even if the exit looks close, if the full consist won't fit with clearance, occupancy remains.

Standard entrance tempts trains in without checking exit capacity. Swap it to chain—trains see "will I actually clear?" and wait upstream instead. Mid-crossing stops drop. This is first-line fix.

The second issue is subtle: exit-side short blocks. Looks like "exited and next signal is near," but if the full consist can't rest clear, that block isn't a true wait zone. Result: rear dangles into intersection, following train can't use it. Cure: ensure full longest-consist fits with headroom post-intersection. If not possible, extend exit as chain to defer judgment, or move waiting elsewhere (stackers, stations).

Non-Crossing Routes Also Blocked: Missing Interior Splits or Chain