diff --git a/doc/tags.md b/doc/tags.md
index 2817a4ba9..8d0792e82 100644
--- a/doc/tags.md
+++ b/doc/tags.md
@@ -140,7 +140,7 @@
 | `(was STR)` | LengPragma | |
 | `(selectany)` | LengPragma, NimonyPragma | |
 | `(pragmas (pragma ...)*)` | LengOther, NimonyOther, NimonyStmt, NiflerKind | begin of pragma section |
-| `(pragmax X (pragmas ...))` | NimonyExpr, NimonyStmt, NiflerKind | pragma expressions |
+| `(pragmax ^(pragmas ...) X)` | NimonyExpr, NimonyStmt, NiflerKind | pragma expressions. Transparent: introduces no scope and no semantics, so a consumer that does not care descends into the body. The `^` marks the pragma list as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the pragmas as code. See `nimony_model.OperandHeadedS` / `bodyInto` |
 | `(align X)` | LengPragma, NimonyPragma | |
 | `(bits X)`| LengPragma, NimonyPragma | |
 | `(vector)` | LengPragma | |
@@ -350,6 +350,41 @@
 | `(assembler)` | NimonyPragma, LengPragma | the `{.assembler.}` **proc pragma** (no children): every construct in the body maps one-to-one to assembler, in source order, with no temporaries invented and no operand materialised. The back end (arkham) owns that checking — see `nativenif/doc/intrinsics.md` §8. Spelled `assembler` rather than `asm` because Nim's parser reads a pragma entry as an expression and so cannot accept a keyword there; it is unrelated to the `(asm X+)` statement |
 | `(deferexpansion)` | NimonyOther | emitted by a template *plugin* as its entire output to say "I cannot answer while the argument still contains type variables — ask me again after instantiation". The compiler then parks the sem-checked call in the tree as `(at <template> <args>…)` instead of replacing it with an expansion — `(at …)` because that is the only unresolved type application a type slot accepts. `subsGenericProc` substitutes into it like any other type, and the instantiation's re-sem turns it back into a call, which drives the plugin again with concrete types. Rejected (a hard error) when no argument contains a generic parameter, which is what makes the retry well-founded |
 | `(needtypes SYM+)` | NimonyOther | emitted by a template *plugin* as its entire output to ask the compiler for the declarations of the named symbols. The compiler appends them to the plugin's second input (`loadTypeDefinitions()`) and runs the plugin again. This is how a plugin resolves a nominal type: it arrives in the main input as an opaque `Symbol`, and a plugin runs in its own process with no way to look it up. Only what is asked for is shipped, so a plugin that never asks pays nothing. Requesting a symbol that was already provided is a hard error, which is what bounds the loop |
+| `(comesfrom ^SYM S*)` | LengStmt, NimonyStmt | a statement list that came from expanding `SYM` — today a template, and the same shape suits any inliner. Carried so the debug backend can emit it as an inlined frame (DWARF `DISubprogram` + `inlinedAt`). Transparent like `(par ...)` is for expressions: it introduces **no scope** and no semantics, so a consumer that does not care descends into the body and skips the rest. The `^` marks `SYM` as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the origin symbol as code. See `nimony_model.OperandHeadedS` / `bodyInto`. Only statement-position (void) expansions are wrapped |
+
+### Child slot notation
+
+A slot in the first column names the kind of child expected there: `D` a
+symbol definition, `Y` a symbol use, `T` a type, `X` an expression, `S` a
+statement, `P` a pragma list, `LIT`/`STR`/`INTLIT` a literal. A nested
+`(tag ...)` means that literal tag. `...` means the form is underspecified.
+
+Modifiers attach to a slot:
+
+| modifier | meaning |
+|---|---|
+| `.X` | a `DotToken` is also allowed in this slot |
+| `X?` | the slot is optional |
+| `X*`, `X+` | the slot repeats |
+| `^X` | **transparent operand** — see below |
+
+`^` marks the leading child of a *transparent* wrapper: a tag that introduces
+no scope and no semantics, so a pass that does not care about it descends
+straight into the body — but whose first child is an operand rather than a
+statement. A walker that recurses into every child as a statement walks that
+operand and corrupts the tree, silently, with the damage surfacing several
+passes later.
+
+Two tags carry it, `(pragmax ^(pragmas ...) X)` and `(comesfrom ^SYM S*)`.
+The marker exists because the slot *kind* cannot express this: `(bind Y)` has
+the same shape as `(comesfrom ^SYM S*)`, and `(when ...)` the same shape as
+`(pragmax ^(pragmas ...) X)`, with opposite walking contracts. `(block .D X)`
+also leads with an operand and is deliberately unmarked — it opens a scope and
+is a `break` target, so it is not transparent.
+
+`src/validator` reads the marker and reports a `case n.stmtKind` branch that
+opens such a tag and walks every child. In the compiler, use
+`nimony_model.bodyInto` (or `bodyStart`), which steps over the slot for you.
 
 ### unpackflat, unpacktup, unpackdecl
 
diff --git a/src/hastur.nim b/src/hastur.nim
index c32483074..bfc659b85 100644
--- a/src/hastur.nim
+++ b/src/hastur.nim
@@ -1621,6 +1621,91 @@ proc runNativeCodegenTests*(dir: string; overwrite: bool) =
   else:
     echo "SUCCESS."
 
+proc extractDebugMetadata(llText, testName: string): string =
+  ## Keep only the debug metadata lines of a `.ll` file, in order. Everything
+  ## else (instructions, types, mangled temporaries) churns with unrelated
+  ## codegen changes and would make the golden useless as a debug-info guard.
+  ##
+  ## Two things are normalized so the golden is portable across checkouts:
+  ## `directory:` holds an absolute path, and module-init/`main` symbols carry
+  ## the module-hash suffix, which depends on the absolute source path.
+  result = ""
+  for line in llText.splitLines:
+    var s = line.strip
+    if not s.startsWith("!"): continue
+    if not ("DILocation" in s or "DISubprogram" in s or
+            "DILocalVariable" in s or "DIFile" in s): continue
+    # `directory: "<abs path>"` -> `directory: "<dir>"`
+    let dirPos = s.find("directory: \"")
+    if dirPos >= 0:
+      let valStart = dirPos + "directory: \"".len
+      let valEnd = s.find('"', valStart)
+      if valEnd > valStart:
+        s = s[0 ..< valStart] & "<dir>" & s[valEnd .. ^1]
+    # `X60Qini_0_<modulehash>` -> `X60Qini_0_<mod>`
+    let sufPos = s.find("X60Qini_0_")
+    if sufPos >= 0:
+      let valStart = sufPos + "X60Qini_0_".len
+      var valEnd = valStart
+      while valEnd < s.len and s[valEnd] notin {'"'}: inc valEnd
+      s = s[0 ..< valStart] & "<mod>" & s[valEnd .. ^1]
+    result.add s
+    result.add "\n"
+
+proc runLLVMDebugTests*(dir: string; overwrite: bool) =
+  ## Golden suite over the LLVM backend's *debug metadata*. For each `.nim`,
+  ## compile with `nimony l` and diff the DWARF-relevant metadata lines of the
+  ## emitted `.ll` against a checked-in `<test>.ll.expected`.
+  ##
+  ## Only `DIFile`/`DISubprogram`/`DILocation`/`DILocalVariable` lines are
+  ## compared: those carry the inlined-frame structure (#1987) and are stable,
+  ## whereas the surrounding IR churns with every unrelated codegen change.
+  ##
+  ## `hastur.mode = skip` — the LLVM backend cannot build the full stdlib yet,
+  ## so these are opt-in via `hastur tests/llvmdebug`. Add `--overwrite` to
+  ## regenerate the goldens after an intended debug-info change.
+  if not skipBuild:
+    buildNimonyToolchain()
+    buildLengc()
+  let t0 = epochTime()
+  var c = TestCounters(total: 0, failures: 0)
+  var files: seq[string] = @[]
+  for x in walkDir(dir):
+    if x.kind == pcFile and x.path.endsWith(".nim") and
+       x.path.extractFilename != "setup.nim":
+      files.add x.path
+  sort files
+  for file in files:
+    inc c.total
+    let cacheArg =
+      if nimcacheDir != "nimcache": "--nimcache:" & quoteShell(nimcacheDir) & " "
+      else: ""
+    # The LLVM backend cannot link the full stdlib yet, so the exit code is not
+    # meaningful here; the `.ll` is written before linking and is what we check.
+    discard execLocal("nimony", "l --silentMake --isMain " & cacheArg &
+      quoteShell(file))
+    let llFile = generatedFile(file, ".ll")
+    if not llFile.fileExists():
+      failure c, file, "lengc .ll", "missing: " & llFile
+      continue
+    let actual = extractDebugMetadata(readFile(llFile), file.splitFile.name)
+    let expectedFile = file.changeFileExt(".ll.expected")
+    if overwrite:
+      writeFile(expectedFile, actual)
+    elif not expectedFile.fileExists():
+      failure c, file, "golden debug metadata", "missing: " & expectedFile
+    else:
+      let expected = readFile(expectedFile)
+      if expected.strip != actual.strip:
+        failure c, file, expected, actual
+  echo c.total - c.failures, " / ", c.total,
+    " llvm-debug tests successful in ",
+    formatFloat(epochTime() - t0, ffDecimal, precision=2), "s."
+  if c.failures > 0:
+    quit "FAILURE: Some llvm-debug tests failed."
+  else:
+    echo "SUCCESS."
+
 # ---- deterministic self-host bootstrap ------------------------------------
 # `bin0/` is a fresh copy of the host-Nim-built toolchain in `bin/`; `binN/`
 # (N >= 1) is `binN-1/`'s nimony recompiling all three self-tools from
diff --git a/src/hexer/constparams.nim b/src/hexer/constparams.nim
index 571781989..c323bc3f9 100644
--- a/src/hexer/constparams.nim
+++ b/src/hexer/constparams.nim
@@ -514,7 +514,7 @@ proc tr(c: var Context; dest: var TokenBuf; n: var Cursor) =
          ImportasS, FromimportS, ImportexceptS, ExportS, ExportexceptS,
          CommentS, DiscardS, UnpackdeclS, AssumeS, AssertS, CallstrlitS,
          InfixS, PrefixS, HcallS, StaticstmtS, BindS, MixinS, UsingS,
-         AsmS, DeferS, NoStmt:
+         AsmS, DeferS, ComesfromS, NoStmt:
         # generic container: copy the head and recurse into the children
         copyInto dest, n:
           while n.hasMore: tr c, dest, n
diff --git a/src/hexer/coro_transform.nim b/src/hexer/coro_transform.nim
index b495e0a7e..bb417e85e 100644
--- a/src/hexer/coro_transform.nim
+++ b/src/hexer/coro_transform.nim
@@ -1274,7 +1274,7 @@ proc trGoto*(c: var Context; dest: var TokenBuf; n: var Cursor) =
             DiscardS, TryS, RaiseS, UnpackdeclS, AssumeS,
             AssertS, CallstrlitS, InfixS, PrefixS, HcallS,
             StaticstmtS, BindS, MixinS, UsingS, AsmS,
-            DeferS, NoStmt:
+            DeferS, ComesfromS, NoStmt:
           dest.addParLe(n.cursorTagId, n.info)
           n.into:
             while n.hasMore:
@@ -1883,7 +1883,7 @@ proc coroTr*(c: var Context; dest: var TokenBuf; n: var Cursor) =
         ExportexceptS, DiscardS, TryS, UnpackdeclS,
         AssumeS, AssertS, CallstrlitS, InfixS, PrefixS,
         HcallS, StaticstmtS, BindS, MixinS, UsingS,
-        AsmS, DeferS, NoStmt:
+        AsmS, DeferS, ComesfromS, NoStmt:
       case n.exprKind
       of CallKinds - {DelayX}:
         trCall c, dest, n
diff --git a/src/hexer/destroyer.nim b/src/hexer/destroyer.nim
index 260cffea6..99f60f814 100644
--- a/src/hexer/destroyer.nim
+++ b/src/hexer/destroyer.nim
@@ -513,7 +513,7 @@ proc tr(c: var Context; n: var Cursor) =
         FromimportS, ImportexceptS, ExportS, ExportexceptS,
         CommentS, DiscardS, UnpackdeclS, AssumeS, AssertS,
         CallstrlitS, InfixS, PrefixS, HcallS, StaticstmtS,
-        BindS, MixinS, UsingS, AsmS, DeferS, NoStmt:
+        BindS, MixinS, UsingS, AsmS, DeferS, ComesfromS, NoStmt:
       if n.isTagLit:
         let isStmtList = n.stmtKind == StmtsS
         c.dest.addParLe(n.cursorTagId, n.info)
diff --git a/src/hexer/desugar.nim b/src/hexer/desugar.nim
index 87f5d390f..3d6f3b22d 100644
--- a/src/hexer/desugar.nim
+++ b/src/hexer/desugar.nim
@@ -1119,7 +1119,7 @@ proc tr(c: var Context; dest: var TokenBuf; n: var Cursor; isTopScope = false) =
           YldS, PragmaxS, ImportasS, ExportexceptS, DiscardS,
           TryS, RaiseS, UnpackdeclS, AssumeS, AssertS,
           CallstrlitS, InfixS, PrefixS, HcallS, StaticstmtS,
-          BindS, MixinS, UsingS, AsmS, DeferS:
+          BindS, MixinS, UsingS, AsmS, DeferS, ComesfromS:
         trSons(c, dest, n)
     of SetconstrX:
       genSetConstr(c, dest, n)
diff --git a/src/hexer/duplifier.nim b/src/hexer/duplifier.nim
index 5342df0f9..dfc674adf 100644
--- a/src/hexer/duplifier.nim
+++ b/src/hexer/duplifier.nim
@@ -695,7 +695,7 @@ proc trOnlyEssentials(c: var Context; n: var Cursor)
           CommentS, DiscardS, TryS, RaiseS, UnpackdeclS, AssumeS,
           AssertS, CallstrlitS, InfixS, PrefixS, HcallS,
           StaticstmtS, BindS, MixinS, UsingS, AsmS, DeferS,
-          NoStmt:
+          ComesfromS, NoStmt:
         # generic statement: copy the head and recurse into the children
         copyInto c.dest, n:
           while n.hasMore: trOnlyEssentials c, n
diff --git a/src/hexer/eraiser.nim b/src/hexer/eraiser.nim
index 7fcdb1ee9..870691cf2 100644
--- a/src/hexer/eraiser.nim
+++ b/src/hexer/eraiser.nim
@@ -224,7 +224,7 @@ proc tr(c: var Context; dest: var TokenBuf; n: var Cursor) =
          FromimportS, ImportexceptS, ExportS, ExportexceptS, CommentS,
          DiscardS, TryS, RaiseS, UnpackdeclS, AssumeS, AssertS,
          CallstrlitS, InfixS, PrefixS, HcallS, StaticstmtS, BindS,
-         MixinS, UsingS, AsmS, DeferS, NoStmt:
+         MixinS, UsingS, AsmS, DeferS, ComesfromS, NoStmt:
         # generic container: copy the head and recurse into the children
         copyInto dest, n:
           while n.hasMore:
diff --git a/src/hexer/iterinliner.nim b/src/hexer/iterinliner.nim
index cd76749d9..6e57db6b2 100644
--- a/src/hexer/iterinliner.nim
+++ b/src/hexer/iterinliner.nim
@@ -295,7 +295,7 @@ proc inlineLoopBody(e: var EContext; dest: var TokenBuf; c: var Cursor; mapping:
         ExportexceptS, CommentS, DiscardS, TryS, RaiseS,
         UnpackdeclS, AssumeS, AssertS, CallstrlitS, InfixS,
         PrefixS, HcallS, StaticstmtS, BindS, MixinS, UsingS,
-        AsmS, DeferS, CoroforS, NoStmt:
+        AsmS, DeferS, CoroforS, ComesfromS, NoStmt:
       if c.substructureKind == KvU:
         # In KvU: first element is field name, don't substitute it
         takeInto dest, c:
@@ -359,7 +359,7 @@ proc inlineIteratorBody(e: var EContext; dest: var TokenBuf;
         ImportexceptS, ExportS, ExportexceptS, CommentS, DiscardS,
         TryS, RaiseS, UnpackdeclS, AssumeS, AssertS, CallstrlitS,
         InfixS, PrefixS, HcallS, StaticstmtS, BindS, MixinS, UsingS,
-        AsmS, DeferS, NoStmt:
+        AsmS, DeferS, ComesfromS, NoStmt:
       takeInto dest, c:
         while c.hasMore:
           inlineIteratorBody(e, dest, c, forStmt, yieldType)
@@ -398,7 +398,7 @@ proc replaceSymbol(e: var EContext; dest: var TokenBuf; c: var Cursor; relations
         ExportS, ExportexceptS, CommentS, DiscardS, TryS, RaiseS,
         UnpackdeclS, AssumeS, AssertS, CallstrlitS, InfixS,
         PrefixS, HcallS, StaticstmtS, BindS, MixinS, UsingS,
-        AsmS, DeferS, NoStmt:
+        AsmS, DeferS, ComesfromS, NoStmt:
       if c.substructureKind == KvU:
         # In KvU: first element is field name, don't substitute it
         takeInto dest, c:
@@ -923,7 +923,7 @@ proc transformStmt(e: var EContext; dest: var TokenBuf; c: var Cursor) =
         ImportexceptS, ExportS, ExportexceptS, CommentS, DiscardS,
         TryS, RaiseS, UnpackdeclS, AssumeS, AssertS, CallstrlitS,
         InfixS, PrefixS, HcallS, StaticstmtS, BindS, MixinS,
-        UsingS, AsmS, DeferS, CoroforS, NoStmt:
+        UsingS, AsmS, DeferS, CoroforS, ComesfromS, NoStmt:
       takeInto dest, c:
         while c.hasMore:
           transformStmt(e, dest, c)
diff --git a/src/hexer/lambdalifting.nim b/src/hexer/lambdalifting.nim
index 97c041e81..b1cb97d0e 100644
--- a/src/hexer/lambdalifting.nim
+++ b/src/hexer/lambdalifting.nim
@@ -325,7 +325,7 @@ proc tr(c: var Context; dest: var TokenBuf; n: var Cursor) =
       ExportexceptS, DiscardS, TryS, RaiseS, UnpackdeclS,
       AssumeS, AssertS, CallstrlitS, InfixS, PrefixS, HcallS,
       StaticstmtS, BindS, MixinS, UsingS, AsmS, DeferS,
-      NoStmt:
+      ComesfromS, NoStmt:
       case n.exprKind
       of CallKinds:
         trCall c, dest, n
@@ -1235,7 +1235,7 @@ proc tre(c: var Context; dest: var TokenBuf; n: var Cursor) =
       ExportexceptS, DiscardS, TryS, RaiseS, UnpackdeclS,
       AssumeS, AssertS, CallstrlitS, InfixS, PrefixS, HcallS,
       StaticstmtS, BindS, MixinS, UsingS, AsmS, DeferS,
-      NoStmt:
+      ComesfromS, NoStmt:
       case n.exprKind
       of CallKinds:
         genCall(c, dest, n)
diff --git a/src/hexer/lengcgen.nim b/src/hexer/lengcgen.nim
index 570605a88..a141fc095 100644
--- a/src/hexer/lengcgen.nim
+++ b/src/hexer/lengcgen.nim
@@ -2047,6 +2047,14 @@ proc trStmt(c: var EContext; dest: var TokenBuf; n: var Cursor; mode = TraverseI
         takeInto dest, n:
           while n.hasMore:
             trStmt c, dest, n, mode
+    of ComesfromS:
+      # Survives into Leng so the LLVM debug backend can emit an inlined frame.
+      # No `openScope`: the wrapper is transparent, like `stmts` and unlike
+      # `scope`. The origin symbol is copied verbatim as the first child.
+      takeInto dest, n:
+        takeTree dest, n # the origin symbol
+        while n.hasMore:
+          trStmt c, dest, n, mode
     of ScopeS:
       c.typeCache.openScope()
       if mode == TraverseTopLevel:
@@ -2575,46 +2583,64 @@ proc initHasCall(c: var EContext; n: Cursor): bool =
   # Now at the init value; scan its subtree
   result = scanInitValue(c, n)
 
+proc trToplevelItem(c: var EContext; dest: var TokenBuf; n: var Cursor) =
+  let sk = n.stmtKind
+  if sk in {GvarS, GletS, TvarS, TletS}:
+    let tag = if sk in {TvarS, TletS}: TvarY else: GvarY
+    if not initHasCall(c, n):
+      # Simple init (literal, nil, etc.): keep at top level.
+      # NIFC can emit "Type var = value;" at C file scope directly.
+      trLocal c, dest, n, tag, TraverseAll, SymId(0)
+    else:
+      # Complex init with function calls: emit a no-init declaration at top
+      # level and place the actual init as an assignment inside the Init proc
+      # body so that any temp variables created by to_stmts remain in scope.
+      let savedN = n
+      trLocal c, dest, n, tag, TraverseSig, SymId(0)
+      var initN = savedN
+      inc initN  # past gvar/glet tag -> at SymbolDef
+      let (initSym, initInfo) = getSymDef(c, initN)
+      skipExportMarker c, initN
+      skip initN  # past pragmas -> at type
+      skip initN  # past type -> at init value
+      swap dest, c.initBody
+      dest.addParLe AsgnS, initInfo
+      dest.addSymUse(initSym, initInfo)
+      trExpr c, dest, initN
+      dest.addParRi()
+      swap dest, c.initBody
+  elif sk == StmtsS:
+    # Nested stmts block: recurse to handle mixed decls and executable code
+    n.into:
+      while n.hasMore:
+        trToplevelItem c, dest, n
+  elif sk == ComesfromS:
+    # A template expanded at module toplevel. The wrapper cannot survive
+    # here: its children get split between file scope (global decls) and
+    # the init proc (their initializers and the executable code), so no
+    # single node can span them. Without this unwrap a global-with-call-init
+    # is hoisted whole and codegen emits the initializer as a C
+    # `__attribute__((constructor))`, which runs before NimMain against
+    # zeroed globals (module plugins crashed with 0xC0000005). Dropping the
+    # marker only costs the debug frame for module-init code.
+    n.into:
+      skip n # the origin symbol
+      while n.hasMore:
+        trToplevelItem c, dest, n
+  elif isTopLevelDecl(n):
+    # Pure declarations and compile-time constructs stay at top level:
+    trStmt c, dest, n, TraverseTopLevel
+  else:
+    # Executable code and local vars go into the init proc body:
+    swap dest, c.initBody
+    trStmt c, dest, n, TraverseAll
+    swap dest, c.initBody
+
 proc trToplevel(c: var EContext; dest: var TokenBuf; n: var Cursor) =
   ## Consumes the whole `(stmts …)` node at `n`, including its close.
   n.into:
     while n.hasMore:
-      let sk = n.stmtKind
-      if sk in {GvarS, GletS, TvarS, TletS}:
-        let tag = if sk in {TvarS, TletS}: TvarY else: GvarY
-        if not initHasCall(c, n):
-          # Simple init (literal, nil, etc.): keep at top level.
-          # NIFC can emit "Type var = value;" at C file scope directly.
-          trLocal c, dest, n, tag, TraverseAll, SymId(0)
-        else:
-          # Complex init with function calls: emit a no-init declaration at top
-          # level and place the actual init as an assignment inside the Init proc
-          # body so that any temp variables created by to_stmts remain in scope.
-          let savedN = n
-          trLocal c, dest, n, tag, TraverseSig, SymId(0)
-          var initN = savedN
-          inc initN  # past gvar/glet tag -> at SymbolDef
-          let (initSym, initInfo) = getSymDef(c, initN)
-          skipExportMarker c, initN
-          skip initN  # past pragmas -> at type
-          skip initN  # past type -> at init value
-          swap dest, c.initBody
-          dest.addParLe AsgnS, initInfo
-          dest.addSymUse(initSym, initInfo)
-          trExpr c, dest, initN
-          dest.addParRi()
-          swap dest, c.initBody
-      elif sk == StmtsS:
-        # Nested stmts block: recurse to handle mixed decls and executable code
-        trToplevel c, dest, n
-      elif isTopLevelDecl(n):
-        # Pure declarations and compile-time constructs stay at top level:
-        trStmt c, dest, n, TraverseTopLevel
-      else:
-        # Executable code and local vars go into the init proc body:
-        swap dest, c.initBody
-        trStmt c, dest, n, TraverseAll
-        swap dest, c.initBody
+      trToplevelItem c, dest, n
 
 proc expand*(infile: string; bits: int; bigEndian: bool; flags: set[CheckMode]; isMain: bool; outdir: string; appType = appConsole) =
   let mp = splitModulePath(infile)
diff --git a/src/hexer/mover.nim b/src/hexer/mover.nim
index 1b57e246c..684d0b6c7 100644
--- a/src/hexer/mover.nim
+++ b/src/hexer/mover.nim
@@ -357,6 +357,10 @@ proc singlePath(pc: Cursor; nested: int; x: Cursor; pcs: var seq[Cursor];
           inc pc
           skip pc # pragma itself
           inc nested
+        of ComesfromS:
+          inc pc
+          skip pc # the origin symbol
+          inc nested
         of LocalDecls:
           inc pc
           if root != NoSymId and pc.kind == SymbolDef and pc.symId == root:
diff --git a/src/hexer/vtables_backend.nim b/src/hexer/vtables_backend.nim
index 466c4226f..e63f3f159 100644
--- a/src/hexer/vtables_backend.nim
+++ b/src/hexer/vtables_backend.nim
@@ -772,7 +772,7 @@ proc collectMethods(c: var Context; n: var Cursor) =
      FromimportS, ImportexceptS, ExportS, ExportexceptS, CommentS,
      DiscardS, TryS, RaiseS, UnpackdeclS, AssumeS, AssertS, CallstrlitS,
      InfixS, PrefixS, HcallS, StaticstmtS, BindS, MixinS, UsingS, AsmS,
-     DeferS, NoStmt:
+     DeferS, ComesfromS, NoStmt:
     skip n
 
 proc emitVTables(c: var Context; dest: var TokenBuf) =
diff --git a/src/hexer/xelim.nim b/src/hexer/xelim.nim
index b04ff4959..994bc7a30 100644
--- a/src/hexer/xelim.nim
+++ b/src/hexer/xelim.nim
@@ -992,6 +992,13 @@ proc trStmt(c: var Context; dest: var TokenBuf; n: var Cursor) =
     copyInto(dest, n):
       while n.hasMore:
         trStmt c, dest, n
+  of ComesfromS:
+    # Like `StmtsS` but for the leading template symbol, and deliberately
+    # without `openScope`: the wrapper is transparent, see `doc/tags.md`.
+    copyInto(dest, n):
+      takeTree dest, n # the origin symbol
+      while n.hasMore:
+        trStmt c, dest, n
 
 proc isIntLike(tk: TypeKind): bool {.inline.} =
   tk in {IntT, UIntT, CharT, BoolT}
@@ -1160,7 +1167,7 @@ proc trExpr(c: var Context; dest: var TokenBuf; n: var Cursor; tar: var Target)
          CommentS, DiscardS, RaiseS, UnpackdeclS, AssumeS,
          AssertS, CallstrlitS, InfixS, PrefixS, HcallS,
          StaticstmtS, BindS, MixinS, UsingS, AsmS, DeferS,
-         NoStmt:
+         ComesfromS, NoStmt:
         trExprLoop c, dest, n, tar
   else:
     bug "unexpected ')' inside"
diff --git a/src/lengc/genstmts.nim b/src/lengc/genstmts.nim
index e1276fc2a..99d1f6541 100644
--- a/src/lengc/genstmts.nim
+++ b/src/lengc/genstmts.nim
@@ -508,6 +508,13 @@ proc genStmt(c: var GeneratedCode; n: var Cursor) =
   of StmtsS:
     n.loopInto:
       genStmt(c, n)
+  of ComesfromS:
+    # Debug-info only: the C backend emits the body as if the wrapper were not
+    # there. No scope is opened, matching `stmts` rather than `scope`.
+    n.into:
+      skip n # the origin symbol
+      while n.hasMore:
+        genStmt(c, n)
   of ScopeS:
     let oldInToplevel = c.inToplevel
     c.inToplevel = false
diff --git a/src/lengc/leng_model.nim b/src/lengc/leng_model.nim
index 117185ac2..848aa0dba 100644
--- a/src/lengc/leng_model.nim
+++ b/src/lengc/leng_model.nim
@@ -105,6 +105,24 @@ const AddrKinds* = {AddrC, HaddrC}
   ## address-taken analysis that misses `haddr` would let a `var` argument slip
   ## past it — so match this set unless the difference is the point.
 
+const OperandHeadedS* = {ComesfromS}
+  ## The Leng twin of `nimony_model.OperandHeadedS` (the two models are split by
+  ## tag vocabulary, not by concept). Transparent statement wrappers - no scope,
+  ## no semantics of their own - whose FIRST child is an operand rather than a
+  ## statement, here `(comesfrom SYM S*)` and its expanded symbol.
+  ##
+  ## A walker that recurses into every child as a statement walks that operand
+  ## and corrupts the tree, silently, with the damage surfacing passes later.
+  ## `src/lengc/shoggoth/cse.nim:994` is the scar: it hoisted a load above a
+  ## declaration the expansion itself makes.
+  ##
+  ## Membership is smaller than on the Nimony side because `pragmax` has no Leng
+  ## tag - Leng attaches pragmas to declarations only. The name is the contract;
+  ## the membership follows whatever `leng_tags.nim` carries.
+  ##
+  ## Transparency is the criterion, not the leading operand: `(block ...)` has
+  ## the same shape and is excluded, being a scope and a `break` target.
+
 proc symKind*(c: Cursor): LengSym {.inline.} =
   if c.isTagLit:
     if rawTagIsLengSym(tagEnum(c)):
diff --git a/src/lengc/llvmcodegen.nim b/src/lengc/llvmcodegen.nim
index 652fa03e9..aa56dc063 100644
--- a/src/lengc/llvmcodegen.nim
+++ b/src/lengc/llvmcodegen.nim
@@ -47,6 +47,14 @@ type
   LLVMGenFlag* = enum
     gfMainModule
 
+  InlineFrame* = object
+    ## One active `(comesfrom ...)` while generating its body: locations inside
+    ## it are scoped to the template's synthetic DISubprogram and chained to
+    ## the call site via `inlinedAt` (#1987).
+    spId*: int               # synthetic DISubprogram of the template
+    spFileId*: int           # DIFile id of the template's definition file
+    callLocId*: int          # DILocation id of the call site (inlinedAt target)
+
   LLVMCurrentProc* = object
     funcIdx*: int            # index into module.funcs (InitFuncIdx for init func)
     dbgLoc*: string          # current debug location for next instruction
@@ -61,6 +69,7 @@ type
     subprogramId*: int
     subprogramFileId*: int
     retainedNodes*: seq[int]
+    inlineFrames*: seq[InlineFrame] # innermost active template expansion last
 
   DebugInfo* = object
     nextMetadataId*: int
@@ -71,6 +80,8 @@ type
     diBasicTypeCache*: Table[string, int] # "i32"/"float"/… -> DIBasicType id
     compositeTypeDone*: HashSet[SymId]    # symIds with fully built DICompositeType
     globalExprs*: seq[int] # DIGlobalVariableExpression IDs for DICompileUnit globals
+    inlineSpCache*: Table[SymId, (int, int)] # template sym -> (spId, spFileId)
+    nullSigId*: int # shared `!DISubroutineType(types: !{null})` for template SPs
 
 type
   PrimTypes* = object
diff --git a/src/lengc/llvmdebug.nim b/src/lengc/llvmdebug.nim
index d79aedd0a..3f4ad10fc 100644
--- a/src/lengc/llvmdebug.nim
+++ b/src/lengc/llvmdebug.nim
@@ -76,23 +76,73 @@ proc getOrCreateDIFile(c: var LLVMCode; fid: FileId): int =
     c.debug.cuId = c.addMetadata("distinct !DICompileUnit(language: DW_LANG_C99, file: !" &
       $result & ", producer: \"lengc\", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)")
 
-proc dbgLocation(c: var LLVMCode; info: NifLineInfo): string =
-  ## Return a `, !dbg !N` suffix for the given source location, or "" if invalid.
-  if not info.isValid: return ""
+proc dbgLocationId(c: var LLVMCode; info: NifLineInfo): int =
+  ## Build a DILocation metadata node for the given source location and return
+  ## its id, or 0 if the location is invalid. While a template expansion is
+  ## active (`inlineFrames` non-empty), the location is scoped to the
+  ## template's synthetic DISubprogram and chained to the call site via
+  ## `inlinedAt` — this is what makes debuggers show the template as an
+  ## inlined frame instead of jumping into its definition file (#1987).
+  if not info.isValid: return 0
   let rawInfo = info
-  if not rawInfo.file.isValid: return ""
+  if not rawInfo.file.isValid: return 0
   let fileId = getOrCreateDIFile(c, rawInfo.file)
-  let scopeId =
-    if fileId == c.currentProc.subprogramFileId:
-      c.currentProc.subprogramId
-    else:
-      c.addMetadata("!DILexicalBlockFile(scope: !" &
-          $c.currentProc.subprogramId &
-        ", file: !" & $fileId & ", discriminator: 0)")
-  let locId = c.addMetadata("!DILocation(line: " & $rawInfo.line &
-    ", column: " & $(rawInfo.col + 1) &
-    ", scope: !" & $scopeId & ")")
-  result = ", !dbg !" & $locId
+  if c.currentProc.inlineFrames.len > 0:
+    let fr = c.currentProc.inlineFrames[^1]
+    let scopeId =
+      if fileId == fr.spFileId:
+        fr.spId
+      else:
+        c.addMetadata("!DILexicalBlockFile(scope: !" & $fr.spId &
+          ", file: !" & $fileId & ", discriminator: 0)")
+    result = c.addMetadata("!DILocation(line: " & $rawInfo.line &
+      ", column: " & $(rawInfo.col + 1) &
+      ", scope: !" & $scopeId &
+      ", inlinedAt: !" & $fr.callLocId & ")")
+  else:
+    let scopeId =
+      if fileId == c.currentProc.subprogramFileId:
+        c.currentProc.subprogramId
+      else:
+        c.addMetadata("!DILexicalBlockFile(scope: !" &
+            $c.currentProc.subprogramId &
+          ", file: !" & $fileId & ", discriminator: 0)")
+    result = c.addMetadata("!DILocation(line: " & $rawInfo.line &
+      ", column: " & $(rawInfo.col + 1) &
+      ", scope: !" & $scopeId & ")")
+
+proc dbgLocation(c: var LLVMCode; info: NifLineInfo): string =
+  ## Return a `, !dbg !N` suffix for the given source location, or "" if invalid.
+  let locId = dbgLocationId(c, info)
+  result = if locId == 0: "" else: ", !dbg !" & $locId
+
+proc getOrCreateInlineSP(c: var LLVMCode; symId: SymId;
+                         bodyInfo: NifLineInfo): (int, int) =
+  ## Get or create the synthetic DISubprogram for template `symId`, shared by
+  ## every call site of the template. Returns (spId, spFileId); (0, 0) when no
+  ## SP can be built. `bodyInfo` is the location of the expansion's first
+  ## statement: template declarations do not survive into Leng, so the body's
+  ## own line info — which points into the template's definition file — is the
+  ## only source for the SP's file and line.
+  if symId in c.debug.inlineSpCache:
+    return c.debug.inlineSpCache[symId]
+  if not bodyInfo.isValid or not bodyInfo.file.isValid: return (0, 0)
+  let fileId = getOrCreateDIFile(c, bodyInfo.file)
+  # A subprogram definition needs a type and a unit; the signature is opaque
+  # (`!{null}`: unknown return, no formals) because a template has neither a
+  # calling convention nor materialized parameters.
+  if c.debug.nullSigId == 0:
+    c.debug.nullSigId = c.addMetadata("!DISubroutineType(types: !{null})")
+  let spId = c.addMetadata("distinct !DISubprogram(name: \"" &
+    nifSymBaseName(c, symId) &
+    "\", scope: !" & $fileId &
+    ", file: !" & $fileId &
+    ", line: " & $bodyInfo.line &
+    ", type: !" & $c.debug.nullSigId &
+    ", scopeLine: " & $bodyInfo.line &
+    ", spFlags: DISPFlagDefinition, unit: !" & $c.debug.cuId & ")")
+  result = (spId, fileId)
+  c.debug.inlineSpCache[symId] = result
 
 proc createSubprogram(c: var LLVMCode; name: string; info: NifLineInfo): int =
   ## Create a DISubprogram metadata node for a function.
@@ -147,18 +197,29 @@ proc emitDbgDeclare(c: var LLVMCode; localName: string; symId: SymId;
     useType = genDIBasicType(c, "int " & $bits, bits, DW_ATE_signed)
   let debugName = if wasName.len > 0: wasName else: nifSymBaseName(c, symId)
   let fileId = getOrCreateDIFile(c, rawInfo.file)
+  # Inside a template expansion the variable belongs to the synthetic
+  # subprogram, and its declare location must carry the matching `inlinedAt`
+  # chain: LLVM's verifier rejects a #dbg_declare whose variable scope and
+  # location scope disagree. `template t = (var x = ...)` is ordinary code,
+  # so this is required, not polish.
+  let inFrame = c.currentProc.inlineFrames.len > 0
+  let varScopeId =
+    if inFrame: c.currentProc.inlineFrames[^1].spId
+    else: c.currentProc.subprogramId
   var varMetadata = "!DILocalVariable(name: \"" & debugName & "\""
   if argNo > 0:
     varMetadata.add ", arg: " & $argNo
-  varMetadata.add ", scope: !" & $c.currentProc.subprogramId &
+  varMetadata.add ", scope: !" & $varScopeId &
     ", file: !" & $fileId &
     ", line: " & $rawInfo.line &
     ", type: !" & $useType & ")"
   let varId = c.addMetadata(varMetadata)
-  c.currentProc.retainedNodes.add varId
-  let locId = c.addMetadata("!DILocation(line: " & $rawInfo.line &
-    ", column: " & $(rawInfo.col + 1) &
-    ", scope: !" & $c.currentProc.subprogramId & ")")
+  if not inFrame:
+    # `retainedNodes` lists the variables scoped to *this* subprogram; one
+    # scoped to a template's synthetic SP does not belong in the proc's list.
+    c.currentProc.retainedNodes.add varId
+  let locId = dbgLocationId(c, info)
+  if locId == 0: return
   c.emitRaw "#dbg_declare(ptr " & localName & ", !" & $varId &
       ", !DIExpression(), !" & $locId & ")"
 
diff --git a/src/lengc/llvmgenstmts.nim b/src/lengc/llvmgenstmts.nim
index c925e1aea..903563fc8 100644
--- a/src/lengc/llvmgenstmts.nim
+++ b/src/lengc/llvmgenstmts.nim
@@ -356,6 +356,40 @@ proc genScopeLLVM(c: var LLVMCode; n: var Cursor) =
       genStmtLLVM c, n
     c.m.closeScope()
 
+proc genComesFromLLVM(c: var LLVMCode; n: var Cursor) =
+  ## `(comesfrom SYM S*)` — the statements of an expanded template. Deliberately
+  ## does NOT open a scope (unlike `genScopeLLVM`): the wrapper is transparent,
+  ## it exists only so the debug backend can emit the body as an inlined frame.
+  ##
+  ## The head's line info is the *call site*; the children's line info points
+  ## into the template's definition file. DWARF wants exactly that split: a
+  ## synthetic `DISubprogram` for the template, and every location inside it
+  ## chained back to the call site through `inlinedAt` (#1987).
+  let callInfo = n.info
+  n.into:
+    var tmplSym = SymId(0)
+    if n.kind == Symbol:
+      tmplSym = n.symId
+    skip n # the origin symbol
+    # Build the call-site location BEFORE pushing, so a nested expansion's
+    # `inlinedAt` chain picks up the enclosing frame and nests correctly.
+    let callLocId = dbgLocationId(c, callInfo)
+    var pushed = false
+    if tmplSym != SymId(0) and callLocId != 0 and c.debug.cuId != 0 and
+        c.currentProc.subprogramId != 0:
+      let (spId, spFileId) = getOrCreateInlineSP(c, tmplSym, n.info)
+      if spId != 0:
+        c.currentProc.inlineFrames.add InlineFrame(spId: spId,
+          spFileId: spFileId, callLocId: callLocId)
+        pushed = true
+    while n.hasMore:
+      genStmtLLVM c, n
+    if pushed:
+      discard c.currentProc.inlineFrames.pop()
+      # The location cache in `dbgLoc` was computed inside the frame; drop it so
+      # the next instruction re-derives one at the outer scope.
+      c.currentProc.dbgLoc = ""
+
 proc genMflagDeclLLVM(c: var LLVMCode; n: var Cursor) =
   n.into:
     if n.kind == SymbolDef:
@@ -510,6 +544,8 @@ proc genStmtLLVM(c: var LLVMCode; n: var Cursor) =
       genStmtLLVM(c, n)
       if c.currentProc.needsTerminator:
         while n.hasMore and n.stmtKind != LabS: skip n
+  of ComesfromS:
+    genComesFromLLVM c, n
   of ScopeS:
     genScopeLLVM c, n
   of InstrS:
diff --git a/src/lengc/shoggoth/cse.nim b/src/lengc/shoggoth/cse.nim
index 9faa21a9e..046e4e0fd 100644
--- a/src/lengc/shoggoth/cse.nim
+++ b/src/lengc/shoggoth/cse.nim
@@ -958,7 +958,12 @@ proc isHoistAnchor(sk: LengStmt): bool {.inline.} =
   # DIFFERENT anchor stacks and defeat all cross-statement CSE (which is the whole
   # point of hoisting a shared load/address to a dominating decl). Unknown/other
   # statements stay anchored (the safe, CSE-suppressing default).
-  sk notin {NoStmt, StmtsS,
+  # `(comesfrom)` is transparent like `(stmts)` — it is a debug-info marker, not
+  # a C block — but it is NOT an anchor for a different reason than `(stmts)`:
+  # anchoring it would be harmless, while treating it as a *scope* would be
+  # wrong, since the locals an expanded template declares belong to the
+  # enclosing block.
+  sk notin {NoStmt, StmtsS, ComesfromS,
             AsgnS, StoreS, CallS, VarS, GvarS, TvarS, ConstS, DiscardS,
             RetS, BreakS, RaiseS, JmpS, LabS, EmitS, KeepovfS, MflagS, VflagS}
 
@@ -986,6 +991,19 @@ proc tr(c: var Context; n: var Cursor) =
         c.curStmt = cursorToPosition(c.orig[], n)   # this block's current child
         tr(c, n)
         c.curStmt = savedStmt
+    of ComesfromS:
+      # Like `StmtsS`, but step over the origin symbol first: falling through to
+      # `trExpr` would walk the whole wrapper as an expression and hoist a temp
+      # out past the declarations the expansion itself makes (`useCpuRegisters`
+      # in `nifreader.nim` declares `{.inject.} p` and then loads `^p`).
+      n.loopInto:
+        if n.kind == Symbol:
+          inc n
+        else:
+          let savedStmt = c.curStmt
+          c.curStmt = cursorToPosition(c.orig[], n)
+          tr(c, n)
+          c.curStmt = savedStmt
     else:
       trExpr(c, n)
     if pushed:
diff --git a/src/models/leng_tags.nim b/src/models/leng_tags.nim
index b8c360cba..49d2c741a 100644
--- a/src/models/leng_tags.nim
+++ b/src/models/leng_tags.nim
@@ -88,9 +88,10 @@ type
     MflagS = (ord(MflagTagId), "mflag")  ## declare a new **materialized** control flow flag `D` of type `bool` initialized to `false`
     VflagS = (ord(VflagTagId), "vflag")  ## declare a new **virtual** control flow flag `D` of type `bool` initialized to `false`
     InstrS = (ord(InstrTagId), "instr")  ## intrinsic/instruction application. Typed exactly like `(call SYM X*)` — `SYM`'s params and return type drive everything — but a distinct tag, so a consumer sees "not an ABI call" from the tag alone. `SYM` must carry `(instruction …)` or `(intrinsic …)`. Selection-final: no pass may substitute a different opcode
+    ComesfromS = (ord(ComesfromTagId), "comesfrom")  ## a statement list that came from expanding `SYM` — today a template, and the same shape suits any inliner. Carried so the debug backend can emit it as an inlined frame (DWARF `DISubprogram` + `inlinedAt`). Transparent like `(par ...)` is for expressions: it introduces **no scope** and no semantics, so a consumer that does not care descends into the body and skips the rest. The `^` marks `SYM` as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the origin symbol as code. See `nimony_model.OperandHeadedS` / `bodyInto`. Only statement-position (void) expansions are wrapped
 
 proc rawTagIsLengStmt*(raw: TagEnum): bool {.inline.} =
-  raw in {CallTagId, GvarTagId, TvarTagId, VarTagId, ConstTagId, ProcTagId, TypeTagId, EmitTagId, AsgnTagId, StoreTagId, KeepovfTagId, ScopeTagId, IfTagId, BreakTagId, WhileTagId, CaseTagId, LabTagId, JmpTagId, RetTagId, StmtsTagId, DiscardTagId, TryTagId, RaiseTagId, OnerrTagId, IteTagId, ItecTagId, LoopTagId, JtrueTagId, MflagTagId, VflagTagId, InstrTagId}
+  raw in {CallTagId, GvarTagId, TvarTagId, VarTagId, ConstTagId, ProcTagId, TypeTagId, EmitTagId, AsgnTagId, StoreTagId, KeepovfTagId, ScopeTagId, IfTagId, BreakTagId, WhileTagId, CaseTagId, LabTagId, JmpTagId, RetTagId, StmtsTagId, DiscardTagId, TryTagId, RaiseTagId, OnerrTagId, IteTagId, ItecTagId, LoopTagId, JtrueTagId, MflagTagId, VflagTagId, InstrTagId, ComesfromTagId}
 
 type
   LengType* = enum
diff --git a/src/models/nifler_tags.nim b/src/models/nifler_tags.nim
index 05d909e4f..b72f663d5 100644
--- a/src/models/nifler_tags.nim
+++ b/src/models/nifler_tags.nim
@@ -60,7 +60,7 @@ type
     ProctypeL = (ord(ProctypeTagId), "proctype")  ## Nimony proc type. Slot 0 carries the nilability tag — either a `.` placeholder or one of `(notnil)`, `(nil)`, `(unchecked)`. Leng proc type, same shape as `(proc D ...)` with anonymous name slot (varargs spec; effects/body slots present but unused).
     PtrL = (ord(PtrTagId), "ptr")  ## `ptr` type contructor; the `(unchecked)` pragma relaxes nil checking on deref
     PragmasL = (ord(PragmasTagId), "pragmas")  ## begin of pragma section
-    PragmaxL = (ord(PragmaxTagId), "pragmax")  ## pragma expressions
+    PragmaxL = (ord(PragmaxTagId), "pragmax")  ## pragma expressions. Transparent: introduces no scope and no semantics, so a consumer that does not care descends into the body. The `^` marks the pragma list as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the pragmas as code. See `nimony_model.OperandHeadedS` / `bodyInto`
     IncludeL = (ord(IncludeTagId), "include")  ## `include` statement
     ImportL = (ord(ImportTagId), "import")  ## `import` statement
     ImportasL = (ord(ImportasTagId), "importas")  ## `import as` statement
diff --git a/src/models/nimony_tags.nim b/src/models/nimony_tags.nim
index 677f5b5d8..2596cf2ca 100644
--- a/src/models/nimony_tags.nim
+++ b/src/models/nimony_tags.nim
@@ -55,7 +55,7 @@ type
     CmdX = (ord(CmdTagId), "cmd")  ## command operation
     CchoiceX = (ord(CchoiceTagId), "cchoice")  ## closed choice
     OchoiceX = (ord(OchoiceTagId), "ochoice")  ## open choice
-    PragmaxX = (ord(PragmaxTagId), "pragmax")  ## pragma expressions
+    PragmaxX = (ord(PragmaxTagId), "pragmax")  ## pragma expressions. Transparent: introduces no scope and no semantics, so a consumer that does not care descends into the body. The `^` marks the pragma list as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the pragmas as code. See `nimony_model.OperandHeadedS` / `bodyInto`
     QuotedX = (ord(QuotedTagId), "quoted")  ## name in backticks
     HderefX = (ord(HderefTagId), "hderef")  ## hidden pointer deref operation
     DdotX = (ord(DdotTagId), "ddot")  ## deref dot: expression, field symbol, field index; optional trailing `STRLIT` is the same *access token* described on `(dot ...)` — names the module the private-field access was written in, which is what a re-check judges it against.
@@ -165,7 +165,7 @@ type
     YldS = (ord(YldTagId), "yld")  ## yield statement
     StmtsS = (ord(StmtsTagId), "stmts")  ## list of statements
     PragmasS = (ord(PragmasTagId), "pragmas")  ## begin of pragma section
-    PragmaxS = (ord(PragmaxTagId), "pragmax")  ## pragma expressions
+    PragmaxS = (ord(PragmaxTagId), "pragmax")  ## pragma expressions. Transparent: introduces no scope and no semantics, so a consumer that does not care descends into the body. The `^` marks the pragma list as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the pragmas as code. See `nimony_model.OperandHeadedS` / `bodyInto`
     InclS = (ord(InclTagId), "incl")  ## `incl` set operation; first child is the set's element type
     ExclS = (ord(ExclTagId), "excl")  ## `excl` set operation; first child is the set's element type
     IncludeS = (ord(IncludeTagId), "include")  ## `include` statement
@@ -192,9 +192,10 @@ type
     UsingS = (ord(UsingTagId), "using")  ## `using` statement
     AsmS = (ord(AsmTagId), "asm")  ## `asm` statement
     DeferS = (ord(DeferTagId), "defer")  ## `defer` statement
+    ComesfromS = (ord(ComesfromTagId), "comesfrom")  ## a statement list that came from expanding `SYM` — today a template, and the same shape suits any inliner. Carried so the debug backend can emit it as an inlined frame (DWARF `DISubprogram` + `inlinedAt`). Transparent like `(par ...)` is for expressions: it introduces **no scope** and no semantics, so a consumer that does not care descends into the body and skips the rest. The `^` marks `SYM` as an operand, not a statement: a statement walker MUST step over it before recursing, or it walks the origin symbol as code. See `nimony_model.OperandHeadedS` / `bodyInto`. Only statement-position (void) expansions are wrapped
 
 proc rawTagIsNimonyStmt*(raw: TagEnum): bool {.inline.} =
-  raw in {CallTagId, CmdTagId, GvarTagId, TvarTagId, VarTagId, ConstTagId, ResultTagId, GletTagId, TletTagId, LetTagId, CursorTagId, PatternvarTagId, ProcTagId, FuncTagId, IteratorTagId, ConverterTagId, MethodTagId, MacroTagId, TemplateTagId, TypeTagId, BlockTagId, EmitTagId, AsgnTagId, ScopeTagId, IfTagId, WhenTagId, BreakTagId, ContinueTagId, ForTagId, WhileTagId, CoroforTagId, CaseTagId, RetTagId, YldTagId, StmtsTagId, PragmasTagId, PragmaxTagId, InclTagId, ExclTagId, IncludeTagId, ImportTagId, ImportasTagId, FromimportTagId, ImportexceptTagId, ExportTagId, ExportexceptTagId, CommentTagId, DiscardTagId, TryTagId, RaiseTagId, UnpackdeclTagId, AssumeTagId, AssertTagId, CallstrlitTagId, InfixTagId, PrefixTagId, HcallTagId, StaticstmtTagId, BindTagId, MixinTagId, UsingTagId, AsmTagId, DeferTagId}
+  raw in {CallTagId, CmdTagId, GvarTagId, TvarTagId, VarTagId, ConstTagId, ResultTagId, GletTagId, TletTagId, LetTagId, CursorTagId, PatternvarTagId, ProcTagId, FuncTagId, IteratorTagId, ConverterTagId, MethodTagId, MacroTagId, TemplateTagId, TypeTagId, BlockTagId, EmitTagId, AsgnTagId, ScopeTagId, IfTagId, WhenTagId, BreakTagId, ContinueTagId, ForTagId, WhileTagId, CoroforTagId, CaseTagId, RetTagId, YldTagId, StmtsTagId, PragmasTagId, PragmaxTagId, InclTagId, ExclTagId, IncludeTagId, ImportTagId, ImportasTagId, FromimportTagId, ImportexceptTagId, ExportTagId, ExportexceptTagId, CommentTagId, DiscardTagId, TryTagId, RaiseTagId, UnpackdeclTagId, AssumeTagId, AssertTagId, CallstrlitTagId, InfixTagId, PrefixTagId, HcallTagId, StaticstmtTagId, BindTagId, MixinTagId, UsingTagId, AsmTagId, DeferTagId, ComesfromTagId}
 
 type
   NimonyType* = enum
diff --git a/src/models/tags.nim b/src/models/tags.nim
index e2320294f..376f8a1d9 100644
--- a/src/models/tags.nim
+++ b/src/models/tags.nim
@@ -353,6 +353,7 @@ type
     AssemblerTagId
     DeferexpansionTagId
     NeedtypesTagId
+    ComesfromTagId
 const
   TagData*: array[TagEnum, (string, int)] = [
     ("InvalidTagId", 0),
@@ -705,5 +706,6 @@ const
     ("stack", 347),
     ("assembler", 348),
     ("deferexpansion", 349),
-    ("needtypes", 350)
+    ("needtypes", 350),
+    ("comesfrom", 351)
   ]
diff --git a/src/nimony/contracts.nim b/src/nimony/contracts.nim
index 7a3fee01b..f010c852d 100644
--- a/src/nimony/contracts.nim
+++ b/src/nimony/contracts.nim
@@ -790,7 +790,8 @@ proc traverseBasicBlock(c: var Context; pc: Cursor): Continuation =
         of IfS, WhenS, WhileS, ForS, CaseS, TryS, RaiseS, ExportS,
            IncludeS, ImportS, FromimportS, ImportexceptS, CommentS, PragmasS,
            ImportasS, ExportexceptS, BindS, MixinS, UsingS,
-           UnpackdeclS, StaticstmtS, AsmS, DeferS, CoroforS:
+           UnpackdeclS, StaticstmtS, AsmS, DeferS, CoroforS, ComesfromS:
+          # `ComesfromS` is unwrapped by controlflow, so it cannot appear here.
           bug "statement not eliminated: " & $pc.stmtKind
         of ProcS, FuncS, IteratorS, ConverterS, MethodS, MacroS, TemplateS, TypeS:
           # declarative junk we don't care about:
@@ -933,6 +934,7 @@ proc traverseToplevel(c: var Context; n: var Cursor) =
      UnpackdeclS, StaticstmtS, AsmS, DeferS,
      CallKindsS, GvarS, TvarS, VarS, ConstS, ResultS,
      GletS, TletS, LetS, CursorS, PatternvarS, BlockS, EmitS, AsgnS, ScopeS,
+     ComesfromS,
      BreakS, ContinueS, RetS, InclS, ExclS, DiscardS, AssumeS, AssertS, NoStmt:
     c.toplevelStmts.takeTree n
 
diff --git a/src/nimony/contracts_fir.nim b/src/nimony/contracts_fir.nim
index 8cf501c91..ef237ccf6 100644
--- a/src/nimony/contracts_fir.nim
+++ b/src/nimony/contracts_fir.nim
@@ -1742,6 +1742,13 @@ proc traverseStmt(c: var NjvlContext; n: var Cursor) =
       n.into:
         while n.hasMore:
           traverseStmt c, n
+    of ComesfromS:
+      # Debug-info marker: traverse the body so writes performed by an expanded
+      # template count towards definite assignment.
+      n.into:
+        skip n # the origin symbol
+        while n.hasMore:
+          traverseStmt c, n
     of CaseS:
       traverseCase c, n
     of TryS:
@@ -1798,6 +1805,11 @@ proc traverseToplevel(c: var NjvlContext; n: var Cursor) =
     n.into:
       while n.hasMore:
         traverseToplevel c, n
+  of ComesfromS:
+    n.into:
+      skip n # the origin symbol
+      while n.hasMore:
+        traverseToplevel c, n
   of PragmaxS:
     n.into:
       skip n # pragmas
diff --git a/src/nimony/controlflow.nim b/src/nimony/controlflow.nim
index da0bc55cd..2b5801c3b 100644
--- a/src/nimony/controlflow.nim
+++ b/src/nimony/controlflow.nim
@@ -679,7 +679,7 @@ proc trExpr(c: var ControlFlow; n: var Cursor; tar: var Target) =
          FromimportS, ImportexceptS, ExportS, ExportexceptS, CommentS,
          DiscardS, RaiseS, UnpackdeclS, AssumeS, AssertS, CallstrlitS,
          InfixS, PrefixS, HcallS, StaticstmtS, BindS, MixinS, UsingS,
-         AsmS, DeferS, NoStmt:
+         AsmS, DeferS, ComesfromS, NoStmt:
         trExprLoop c, n, tar
   else:
     bug "unreachable"
@@ -1003,6 +1003,13 @@ proc trStmt(c: var ControlFlow; n: var Cursor) =
     n.into:
       while n.hasMore:
         trStmt c, n
+  of ComesfromS:
+    # Transparent wrapper: the CFG models the expanded statements themselves,
+    # so drop it like `StmtsS`. `bodyInto` steps over the origin symbol, which a
+    # plain `into` would walk as a statement (see `OperandHeadedS`).
+    n.bodyInto:
+      while n.hasMore:
+        trStmt c, n
   of ScopeS, StaticstmtS:
     c.dest.addParLe(n.cursorTagId, n.info)
     c.typeCache.openScope()
diff --git a/src/nimony/deferstmts.nim b/src/nimony/deferstmts.nim
index 5ad19e3ae..30090688e 100644
--- a/src/nimony/deferstmts.nim
+++ b/src/nimony/deferstmts.nim
@@ -173,7 +173,7 @@ proc trStmt(c: var Context; dest: var TokenBuf; n: var Cursor) =
        StmtsS, PragmasS, PragmaxS, InclS, ExclS, IncludeS, ImportS, ImportasS,
        FromimportS, ImportexceptS, ExportS, ExportexceptS, CommentS, DiscardS,
        RaiseS, UnpackdeclS, AssumeS, AssertS, CallstrlitS, InfixS, PrefixS,
-       HcallS, StaticstmtS, BindS, MixinS, UsingS, AsmS, NoStmt:
+       HcallS, StaticstmtS, BindS, MixinS, UsingS, AsmS, ComesfromS, NoStmt:
       copyInto dest, n:
         while n.hasMore:
           trStmt c, dest, n
diff --git a/src/nimony/derefs.nim b/src/nimony/derefs.nim
index eec4cd2f0..d005b211e 100644
--- a/src/nimony/derefs.nim
+++ b/src/nimony/derefs.nim
@@ -1446,6 +1446,14 @@ proc tr(c: var Context; n: var Cursor; e: Expects) =
         c.typeCache.openScope()
         trSons c, n, WantT
         c.typeCache.closeScope()
+      of ComesfromS:
+        # The first child is the origin symbol, not an expression: `trSons`
+        # would analyse it as one. Copy it, then walk the body. No new scope —
+        # the wrapper is transparent.
+        takeInto c.dest, n:
+          takeTree c.dest, n # the origin symbol
+          while n.hasMore:
+            tr c, n, WantT
       of TypeS:
         trType c, n
       else:
diff --git a/src/nimony/nimony_model.nim b/src/nimony/nimony_model.nim
index 23910ccfd..e548bfd80 100644
--- a/src/nimony/nimony_model.nim
+++ b/src/nimony/nimony_model.nim
@@ -438,6 +438,58 @@ proc skipModifier*(a: Cursor): Cursor =
 const
   LocalDecls* = {VarS, LetS, ConstS, ResultS, CursorS, PatternvarS, GvarS, TvarS, GletS, TletS}
 
+  OperandHeadedS* = {PragmaxS, ComesfromS}
+    ## Statement tags that are *transparent* - they introduce no scope and no
+    ## semantics of their own, so a pass that does not care about the tag may
+    ## descend straight into the body - but whose FIRST child is an operand
+    ## rather than a statement:
+    ##
+    ##   (pragmax (pragmas ...) <body>)   the pragma list
+    ##   (comesfrom SYM S*)               the expanded symbol
+    ##
+    ## A walker that recurses into every child as a statement is therefore wrong
+    ## here, and wrong silently: it walks the operand, corrupts the tree, and the
+    ## damage surfaces passes later. Use `bodyInto` / `bodyStart` below instead
+    ## of opening the node by hand.
+    ##
+    ## Transparency is the membership criterion, not the shape of the first
+    ## child. `(block .D X)` also leads with an operand and is deliberately NOT a
+    ## member: it opens a scope and is a `break` target, so no pass may descend
+    ## into it and forget it was there. `(corofor X S)` likewise - its leading
+    ## call must be lowered, not skipped.
+    ##
+    ## Mirrored on the Leng side as `leng_model.OperandHeadedS` (the two models
+    ## are split by tag vocabulary, not by concept), which holds `{ComesfromS}`
+    ## only - `pragmax` has no Leng tag.
+
+proc bodyStart*(n: Cursor): Cursor =
+  ## Cursor at the first *statement* child of `n`, stepping over the leading
+  ## operand when `n` is operand-headed. The read-only half of the pair: takes
+  ## `n` by value and does not advance it, so it creates no traversal obligation
+  ## for the caller. Mirrors nifcore's `sub`, which it wraps.
+  result = sub(n)
+  if n.stmtKind in OperandHeadedS: skip result
+
+template bodyInto*(n: var Cursor; body: untyped) =
+  ## Like `into`, but steps over the leading operand first when `n` is
+  ## operand-headed, so `body` sees statement children only:
+  ##
+  ##   n.bodyInto:
+  ##     while n.hasMore: trStmt c, n
+  ##
+  ## Restores the outer bounds afterwards and requires `body` to consume every
+  ## remaining child, exactly as `into` does. This is the consuming half of the
+  ## pair and what a pass that does not care about the wrapper should reach for -
+  ## it makes the correct walk shorter to write than the wrong one.
+  ##
+  ## The membership test must happen before `enterScope`: afterwards `n` points
+  ## at the first child and no longer carries the tag.
+  let operandHeaded = n.stmtKind in OperandHeadedS
+  let cursorScope = enterScope(n)
+  if operandHeaded: skip n
+  body
+  leaveScope(n, cursorScope)
+
 template skipToLocalType*(n) =
   inc n # skip ParLe
   inc n # skip name
diff --git a/src/nimony/renderer.nim b/src/nimony/renderer.nim
index 8b295e53b..47ae16f0c 100644
--- a/src/nimony/renderer.nim
+++ b/src/nimony/renderer.nim
@@ -1429,6 +1429,15 @@ proc gsub(g: var SrcGen, n: var Cursor, c: Context, fromStmtList = false, isTopL
           while n.hasMore:
             gsub(g, n, c)
 
+      of ComesfromS:
+        # Debug-info marker with no source syntax: render the expanded
+        # statements alone, so `astToStr` and error messages show what the
+        # user wrote rather than the wrapper.
+        n.into:
+          skip n # the origin symbol
+          while n.hasMore:
+            gsub(g, n, c)
+
       of NoStmt:
         case n.substructureKind
         of RangeU:
diff --git a/src/nimony/sem.nim b/src/nimony/sem.nim
index b21ec2b50..72505885e 100644
--- a/src/nimony/sem.nim
+++ b/src/nimony/sem.nim
@@ -5152,6 +5152,23 @@ proc semExpr*(c: var SemContext; dest: var TokenBuf; it: var Item; flags: set[Se
       of CoroforS:
         buildErr c, dest, it.n.info, "`corofor` is a hexer-internal shape and must not appear in source"
         skip it.n
+      of ComesfromS:
+        # Emitted by `semTemplateCall`. It does come back through here: a
+        # template expanded inside a *generic* body is stored with the wrapper
+        # and re-sem'd at instantiation. Preserve the head and the template
+        # symbol, then sem the body as an ordinary statement list. No new scope
+        # (`isNewScope = false` in effect): the wrapper must stay transparent
+        # or `{.inject.}` symbols would stop escaping.
+        dest.addParLe(ComesfromS, it.n.info)
+        it.n.into:
+          dest.addSubtree it.n # the template's symbol
+          skip it.n
+          while it.n.hasMore:
+            if not isLastSon(it.n):
+              semStmt c, dest, it.n, false
+            else:
+              semExpr c, dest, it
+        dest.addParRi()
       of VarS:
         localSigGuard c:
           semLocal c, dest, it, VarY
diff --git a/src/nimony/semcall.nim b/src/nimony/semcall.nim
index 9258f1f5d..9089ba7d7 100644
--- a/src/nimony/semcall.nim
+++ b/src/nimony/semcall.nim
@@ -218,6 +218,22 @@ proc semTemplateCall(c: var SemContext; dest: var TokenBuf; it: var Item; fnId:
     expandedInto.addDotToken() # sentinel so the final `inc` stays in bounds
     var a = Item(n: cursorAt(expandedInto, 0), typ: c.types.autoType)
     let aInfo = a.n.info
+    # make sure template body expression matches return type, mirrored with `semProcBody`:
+    # Hoisted above `semExpr` so the void case can be known before emitting:
+    # both `m.returnType` and `m.inferred` are fixed by `sigmatch` before we run.
+    let returnType =
+      if m.inferred.len == 0 or m.returnType.isDotToken:
+        m.returnType
+      else:
+        instantiateType(c, m.returnType, m.inferred)
+    # A void expansion is a *statement*, so it can be wrapped in `(comesfrom ...)`
+    # to record where it came from; the debug backend turns that into a DWARF
+    # inlined frame (#1987). Non-void expansions are expressions and `beforeCall`
+    # must keep pointing at the value for `commonType`, so they stay unwrapped.
+    let markExpansion = returnType.typeKind == VoidT
+    if markExpansion:
+      dest.addParLe(ComesfromS, callInfo)
+      dest.addSymUse fnId, callInfo
     inc c.routine.inInst
     # An `untyped` template's body is published unresolved, so its field
     # accesses resolve HERE for the first time and must be judged against the
@@ -228,12 +244,6 @@ proc semTemplateCall(c: var SemContext; dest: var TokenBuf; it: var Item; fnId:
     c.visOwner.add VisOwner(module: extractModule(pool.syms[fnId]),
                             file: res.decl.info.file.uint32)
     semExpr c, dest, a, flags
-    # make sure template body expression matches return type, mirrored with `semProcBody`:
-    let returnType =
-      if m.inferred.len == 0 or m.returnType.isDotToken:
-        m.returnType
-      else:
-        instantiateType(c, m.returnType, m.inferred)
     case returnType.typeKind
     of UntypedT:
       # untyped return type ignored, maybe could be handled in commonType
@@ -244,6 +254,8 @@ proc semTemplateCall(c: var SemContext; dest: var TokenBuf; it: var Item; fnId:
       commonType c, dest, a, beforeCall, returnType
     discard c.visOwner.pop()
     dec c.routine.inInst
+    if markExpansion:
+      dest.addParRi()
     # now match to expected type:
     it.kind = a.kind
     typeofCallIs c, dest, it, beforeCall, a.typ
diff --git a/src/njvl/finalir.nim b/src/njvl/finalir.nim
index 77f97e1af..8528acae0 100644
--- a/src/njvl/finalir.nim
+++ b/src/njvl/finalir.nim
@@ -727,6 +727,14 @@ proc trStmt(c: var Context; dest: var TokenBuf; n: var Cursor) =
   case n.stmtKind
   of StmtsS, ScopeS:
     trScopedBody c, dest, n
+  of ComesfromS:
+    # Debug-info marker; Final IR does not model it. Emit the body inline so
+    # `result` initialization through an expanded template stays visible to the
+    # analysis, and open no scope (locals belong to the enclosing one).
+    n.into:
+      skip n # the origin symbol
+      while n.hasMore:
+        trStmt c, dest, n
   of AsgnS:
     trAsgn c, dest, n
   of IfS:
diff --git a/src/njvl/nj.nim b/src/njvl/nj.nim
index 12b8df6b4..1b16d79d1 100644
--- a/src/njvl/nj.nim
+++ b/src/njvl/nj.nim
@@ -1348,6 +1348,16 @@ proc trGuardedStmts(c: var Context; b: var BasicBlock; dest: var TokenBuf; n: va
     n = stmtsStart; skip n
     maybeCloseGuard(c, dest, g2, false)
 
+  of ComesfromS:
+    # Debug-info marker only. Walk the body inline (no wrapping node, no new
+    # scope) so assignments made by an expanded template are seen by the
+    # definite-assignment analysis.
+    let bodyStart = n
+    n = sub(n)
+    skip n # the origin symbol
+    while n.hasMore:
+      trGuardedStmts(c, b, dest, n, false)
+    n = bodyStart; skip n
   of AsgnS:
     trAsgn c, b, dest, n
   of IfS:
diff --git a/src/njvl/vl.nim b/src/njvl/vl.nim
index 7861e8cfa..fcefba019 100644
--- a/src/njvl/vl.nim
+++ b/src/njvl/vl.nim
@@ -301,6 +301,14 @@ proc trStmt(c: var Context; dest: var TokenBuf; n: var Cursor) =
       takeTree dest, n
     of ContinueS:
       skip n
+    of ComesfromS:
+      # The first child is the origin *symbol*, not a statement: it must be
+      # copied verbatim rather than run through `trStmt`, which would try to
+      # version it and lose the writes in the body.
+      takeInto dest, n:
+        takeTree dest, n # the origin symbol
+        while n.hasMore:
+          trStmt c, dest, n
     else:
       takeInto dest, n:
         while n.hasMore:
diff --git a/src/validator/tags_grammar.nim b/src/validator/tags_grammar.nim
index a4d0a2fe0..8a3bb4aa3 100644
--- a/src/validator/tags_grammar.nim
+++ b/src/validator/tags_grammar.nim
@@ -39,6 +39,15 @@ type
     dotAllowed*: bool ## `.D` in tags.md: DotToken is allowed in this slot
     optional*: bool   ## trailing `?`
     repeated*: bool   ## trailing `*` or `+`
+    transparent*: bool
+      ## leading `^` in tags.md: this slot is an operand of a *transparent*
+      ## wrapper, and a walker that recurses into children as statements must
+      ## step over it. See `nimony_model.OperandHeadedS`.
+      ##
+      ## Transparency cannot be inferred from `kind`: `(bind Y)` and
+      ## `(comesfrom ^SYM S*)` have identical slot kinds and opposite walking
+      ## contracts, as do `(when ...)` and `(pragmax ^(pragmas ...) X)`. It has
+      ## to be stated, so the row states it.
 
   TagSpec* = object
     tag*: string
@@ -67,6 +76,11 @@ proc classifyChild*(s: string): ChildSpec =
     result.repeated = true
     name = name[0..^2]
 
+  # `^` before `.`, so `^.D` reads as "transparent, dot allowed".
+  if name.len > 1 and name[0] == '^':
+    result.transparent = true
+    name = name[1..^1]
+
   if name.len > 1 and name[0] == '.':
     result.dotAllowed = true
     name = name[1..^1]
@@ -79,7 +93,13 @@ proc classifyChild*(s: string): ChildSpec =
     of "X": ckX
     of "S": ckS
     of "XS": ckXS
-    of "Y": ckY
+    of "Y", "SYM": ckY
+      # `SYM` is `Y` spelled out: a symbol *use*, not a definition. Only
+      # `(instr SYM X*)` and `(comesfrom SYM S*)` use the long form, and both
+      # mean the same thing - `instr`'s own row says it is "typed exactly like
+      # `(call SYM X*)`". Without this it fell to the `else` below and landed in
+      # `ckAny`, which matches every slot, so the two rows documented a symbol
+      # and validated as "don't care".
     of "LIT", "STR", "INTLIT", "INT_LIT", "STR_LIT": ckLit
     else:
       if name.startsWith("("):
@@ -110,7 +130,14 @@ proc parseTagSpec*(spec: string): TagSpec =
     if s[pos] == ' ':
       inc pos
       continue
-    if s[pos] == '(':
+    if s[pos] == '(' or (s[pos] == '^' and pos + 1 < s.len and s[pos+1] == '('):
+      # A nested `(tag ...)` slot, optionally marked `^` for a transparent
+      # operand. The marker is read here as well as in `classifyChild`, since
+      # nested slots do not go through it.
+      var transparent = false
+      if s[pos] == '^':
+        transparent = true
+        inc pos
       var depth = 1
       inc pos
       while pos < s.len and depth > 0:
@@ -121,7 +148,7 @@ proc parseTagSpec*(spec: string): TagSpec =
       if pos < s.len and s[pos] in {'?', '*', '+'}:
         suffix = $s[pos]
         inc pos
-      var child = ChildSpec(kind: ckNested)
+      var child = ChildSpec(kind: ckNested, transparent: transparent)
       if suffix == "?": child.optional = true
       elif suffix in ["*", "+"]: child.repeated = true
       result.children.add child
@@ -154,6 +181,15 @@ proc parseTagSpec*(spec: string): TagSpec =
         result.isVarargs = true
       pos = j
 
+proc isOperandHeaded*(spec: TagSpec): bool =
+  ## True when this form is a transparent wrapper whose first child is an
+  ## operand: a statement walker must step over that child.
+  ##
+  ## Read straight off the `^` marker in `doc/tags.md`, so it is a property of
+  ## the grammar rather than of the row's prose.
+  spec.children.len > 0 and spec.children[0].transparent and
+    not spec.isVarargs
+
 proc parseTagsMdLines*(mdLines: openArray[string]): TagGrammar =
   ## Parse the Markdown table in `doc/tags.md` split into lines.
   result = initTable[string, seq[TagSpec]]()
diff --git a/src/validator/validator.nim b/src/validator/validator.nim
index 2d6122fd5..f48d4da7f 100644
--- a/src/validator/validator.nim
+++ b/src/validator/validator.nim
@@ -444,6 +444,138 @@ proc scanForNonExhaustiveCases(ctx: var CheckContext; buf: var TokenBuf) =
             break
           skip peek
 
+# ---------------------------------------------------------------------------
+# Step 2c: Check that operand-headed tags aren't walked as all-statements
+# ---------------------------------------------------------------------------
+
+proc firstSlotIsOperand(ctx: CheckContext; tag: string): bool =
+  ## True when every documented form of `tag` marks its first child `^`, i.e.
+  ## the tag is a transparent wrapper whose leading child is an operand.
+  ##
+  ## The marker is needed because slot *kind* does not separate the cases:
+  ## `(bind Y)` and `(mixin Y)` lead with `ckY` exactly like
+  ## `(comesfrom ^SYM S*)`, and `(when ...)`, `(using ...)`, `(if ...)` lead
+  ## with `ckNested` exactly like `(pragmax ^(pragmas ...) X)`. None of those is
+  ## transparent, and keying on kind alone flagged all of them - measured, 11 of
+  ## the 15 validator pass files failed that way.
+  ##
+  ## Requiring *every* form to carry it is deliberate: a tag with one
+  ## operand-headed form and one ordinary form has no single walking contract,
+  ## so the check stays out of it.
+  if tag notin ctx.grammar: return false
+  for form in ctx.grammar[tag]:
+    if not form.isOperandHeaded: return false
+  result = ctx.grammar[tag].len > 0
+
+const
+  NodeOpeners = ["into", "loopInto", "takeInto", "copyInto", "copyIntoKind",
+                 "buildTree", "withTree"]
+    ## Templates that descend into the current node and run a block over its
+    ## children. These are what make a branch a generic child walk.
+  OperandSteppers = ["skip", "takeTree", "inc", "copyTree", "copyIntoKind"]
+    ## Calls that consume exactly one child, discharging the leading operand.
+  ContractCarriers = ["bodyInto", "bodyStart"]
+    ## Accessors that handle the operand themselves - see `nimony_model`.
+
+proc branchOpensNodeGenerically(body: Cursor): bool =
+  ## True when the branch descends into the node and walks its children,
+  ## i.e. when the operand-headed contract applies to it at all.
+  ##
+  ## A branch that dispatches elsewhere - `case n.exprKind`, a call to a
+  ## dedicated `trPragmax`, `bug "unreachable"` - never touches the children
+  ## itself and is not this check's business, whatever tags it lists.
+  var n = body
+  n.linearScan:
+    if n.isTagLit and globalTags.tags[n.cursorTagId] in CallTags:
+      if extractCalleeName(n) in NodeOpeners: return true
+  result = false
+
+proc branchStepsOverOperand(body: Cursor): bool =
+  ## True when the branch discharges the leading operand before walking the
+  ## rest. Recognised forms:
+  ##
+  ##   n.bodyInto: ...              the accessor - handles the skip itself
+  ##   n.into: skip n; ...          the hand-written form the 25 sites use
+  ##   takeInto dest, n: takeTree dest, n; ...
+  ##
+  ## Anything that opens the node and goes straight to the loop is a violation.
+  var n = body
+  n.linearScan:
+    if n.isTagLit and globalTags.tags[n.cursorTagId] in CallTags:
+      let callee = extractCalleeName(n)
+      if callee in ContractCarriers: return true
+      if callee in NodeOpeners:
+        # Look inside the block for a leading `skip` / `takeTree` that
+        # discharges the operand before the loop.
+        var inner = childCursor(n)
+        while inner.hasMore:
+          if inner.isTagLit and globalTags.tags[inner.cursorTagId] == "stmts":
+            var first = childCursor(inner)
+            if first.isTagLit and globalTags.tags[first.cursorTagId] in CallTags:
+              if extractCalleeName(first) in OperandSteppers: return true
+            return false
+          skip inner
+        return false
+  result = false
+
+proc scanForOperandHeadedWalks(ctx: var CheckContext; buf: var TokenBuf) =
+  ## Reject a `case n.stmtKind` branch for an operand-headed tag that opens the
+  ## node and recurses into every child as a statement - it walks the leading
+  ## operand. This is the shape that broke `derefs`, `vl` and `cse` when
+  ## `(comesfrom SYM S*)` was introduced, each caught only by a downstream
+  ## suite rather than at edit time.
+  var n = beginRead(buf)
+  assert n.isTagLit
+  n.linearScan:
+    let tag = globalTags.tags[n.cursorTagId]
+    if tag == "case":
+      var peek = childCursor(n)
+      var discr = ""
+      if peek.isTagLit:
+        discr = extractLastDotField(peek)
+      if discr == "stmtKind":
+        if peek.hasMore: skip peek  # skip discriminator
+        while peek.hasMore:
+          if peek.isTagLit and globalTags.tags[peek.cursorTagId] == "of":
+            # (of (ranges LabelA LabelB ...) <body>)
+            var branch = childCursor(peek)
+            var labels: seq[string] = @[]
+            if branch.isTagLit and globalTags.tags[branch.cursorTagId] == "ranges":
+              var lab = childCursor(branch)
+              while lab.hasMore:
+                # Unsemchecked nifler output: the labels are `Ident` tokens,
+                # not resolved `Symbol`s.
+                if lab.kind == Ident:
+                  labels.add enumNameToTag(lab.strVal)
+                skip lab
+            skip branch  # past (ranges ...) to the body
+            var offenders: seq[string] = @[]
+            for l in labels:
+              if l.len > 0 and firstSlotIsOperand(ctx, l): offenders.add l
+            # The contract only binds a branch that actually walks the node's
+            # children. A branch that dispatches elsewhere - the big group
+            # branches in `lambdalifting` and `deferstmts` fall through to
+            # `case n.exprKind` - never touches the leading operand, so it
+            # cannot get it wrong. Testing for the walk structurally is what
+            # makes this sound; counting labels only approximated it.
+            if offenders.len > 0 and branchOpensNodeGenerically(branch) and
+               not branchStepsOverOperand(branch):
+              # A warning, not an error, and the severity is load-bearing.
+              # Eight branches in the existing pass files are in exactly this
+              # shape - `eraiser.nim:216`, `deferstmts.nim:171` and friends list
+              # the two tags among 40-odd "generic container" kinds and copy
+              # every child through. Whether that is a bug depends on what the
+              # pass then does with the operand: `eraiser` copying it verbatim
+              # is harmless, a pass that rewrites what it walks is not. The
+              # check cannot tell those apart, and task 7.1 rules out rewriting
+              # working passes to satisfy it. So: report the fact, let the
+              # author judge, and keep the build green.
+              addWarning(ctx, peek.info, "case stmtKind",
+                "branch for `" & offenders.join("`, `") &
+                "` walks every child as a statement, but the first child is an " &
+                "operand; use `bodyInto` or step over it explicitly")
+          skip peek
+
 # ---------------------------------------------------------------------------
 # Step 3: Obligation tracking — scan procs for unmatched skip/emit
 # ---------------------------------------------------------------------------
@@ -1251,6 +1383,7 @@ proc main() =
   # the check only in --strict mode.
   if strict:
     scanForNonExhaustiveCases(ctx, buf)
+    scanForOperandHeadedWalks(ctx, buf)
 
   # Obligation tracking: check cursor params are consumed
   scanObligations(ctx, procMetas)
diff --git a/tests/check_tags/fake_operand_headed.expected b/tests/check_tags/fake_operand_headed.expected
new file mode 100644
index 000000000..84ffda7ab
--- /dev/null
+++ b/tests/check_tags/fake_operand_headed.expected
@@ -0,0 +1,6 @@
+tests/check_tags/fake_operand_headed.nim(18, 3) Error: `else` branch not allowed; enumerate all values for exhaustive checking [case stmtKind]
+tests/check_tags/fake_operand_headed.nim(32, 3) Error: `else` branch not allowed; enumerate all values for exhaustive checking [case stmtKind]
+tests/check_tags/fake_operand_headed.nim(57, 3) Error: `else` branch not allowed; enumerate all values for exhaustive checking [case stmtKind]
+tests/check_tags/fake_operand_headed.nim(19, 3) Warning: branch for `comesfrom` walks every child as a statement, but the first child is an operand; use `bodyInto` or step over it explicitly [case stmtKind]
+tests/check_tags/fake_operand_headed.nim(23, 3) Warning: branch for `pragmax` walks every child as a statement, but the first child is an operand; use `bodyInto` or step over it explicitly [case stmtKind]
+tests/check_tags/fake_operand_headed.nim(30, 1) Warning: cursor `n` not advanced on every code path [trConforming]
diff --git a/tests/check_tags/fake_operand_headed.nim b/tests/check_tags/fake_operand_headed.nim
new file mode 100644
index 000000000..ab98a4ffe
--- /dev/null
+++ b/tests/check_tags/fake_operand_headed.nim
@@ -0,0 +1,61 @@
+# Fake compiler pass exercising the operand-headed statement check.
+#
+# `(pragmax (pragmas ...) X)` and `(comesfrom SYM S*)` are transparent wrappers
+# whose FIRST child is an operand, not a statement (see `nimony_model`'s
+# `OperandHeadedS`). A branch that opens the node and walks every child as a
+# statement walks that operand. Both the violating and the conforming forms are
+# here so the golden proves the check fires *and* that it stays quiet.
+
+import std/assertions
+include "../../src/lib/nifprelude"
+import "../../src/nimony/nimony_model"
+
+type Context = object
+  counter: int
+
+proc trViolating(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  ## Each of these opens the node and recurses into every child. VIOLATION.
+  case n.stmtKind
+  of ComesfromS:
+    copyInto dest, n:
+      while n.hasMore:
+        trViolating c, dest, n
+  of PragmaxS:
+    copyInto dest, n:
+      while n.hasMore:
+        trViolating c, dest, n
+  else:
+    takeTree dest, n
+
+proc trConforming(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  ## The same walks done right: the leading operand is discharged first.
+  case n.stmtKind
+  of ComesfromS:
+    # `bodyInto` steps over the origin symbol itself.
+    n.bodyInto:
+      while n.hasMore:
+        trConforming c, dest, n
+  of PragmaxS:
+    # The hand-written form the existing 25 sites use.
+    copyInto dest, n:
+      takeTree dest, n   # the pragma list
+      while n.hasMore:
+        trConforming c, dest, n
+  of StmtsS, ScopeS:
+    # Not operand-headed: every child really is a statement.
+    copyInto dest, n:
+      while n.hasMore:
+        trConforming c, dest, n
+  else:
+    takeTree dest, n
+
+proc trDispatching(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  ## Lists the tags but never walks the children itself - it hands off. This is
+  ## the shape of the big "generic container" group branches in `eraiser` and
+  ## `deferstmts`, and it must NOT be reported: a branch that does not descend
+  ## cannot get the leading operand wrong.
+  case n.stmtKind
+  of PragmaxS, ComesfromS, StmtsS, IfS, WhileS, CaseS:
+    trConforming c, dest, n
+  else:
+    takeTree dest, n
diff --git a/tests/llvmdebug/hastur.mode b/tests/llvmdebug/hastur.mode
new file mode 100644
index 000000000..e32e76dd5
--- /dev/null
+++ b/tests/llvmdebug/hastur.mode
@@ -0,0 +1 @@
+skip
diff --git a/tests/llvmdebug/setup.nim b/tests/llvmdebug/setup.nim
new file mode 100644
index 000000000..72d1b5e6b
--- /dev/null
+++ b/tests/llvmdebug/setup.nim
@@ -0,0 +1,25 @@
+## Custom runner for the LLVM debug-info golden tests: compile each `.nim`
+## with the LLVM backend (`nimony l`) and diff the DWARF-relevant metadata of
+## the emitted `.ll` against the checked-in `<test>.ll.expected`.
+##
+## This directory is `hastur.mode = skip`, so the default `hastur all` sweep
+## leaves it out (the LLVM backend cannot build the full stdlib yet); run it
+## explicitly with `hastur tests/llvmdebug` (add `--overwrite` to regenerate
+## the goldens after an intended debug-info change).
+import std / [os, strutils]
+import "../../src/hastur"
+
+proc arg(name: string): string =
+  let prefix = "--" & name & ":"
+  for p in commandLineParams():
+    if p.startsWith(prefix): return p[prefix.len .. ^1]
+  result = ""
+
+if arg("bindir").len > 0:
+  toolchainDir = arg("bindir")
+  skipBuild = true
+if arg("cachedir").len > 0: nimcacheDir = arg("cachedir")
+let overwrite = "--overwrite" in commandLineParams()
+let dir = if arg("dir").len > 0: arg("dir") else: getCurrentDir()
+
+runLLVMDebugTests(dir, overwrite)
diff --git a/tests/llvmdebug/ttemplate_frames.ll.expected b/tests/llvmdebug/ttemplate_frames.ll.expected
new file mode 100644
index 000000000..27e56160e
--- /dev/null
+++ b/tests/llvmdebug/ttemplate_frames.ll.expected
@@ -0,0 +1,35 @@
+!2 = !DIFile(filename: "ttemplate_frames.nim", directory: "<dir>")
+!4 = distinct !DISubprogram(name: "run", scope: !2, file: !2, line: 18, type: !17, scopeLine: 18, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !18)
+!5 = !DILocalVariable(name: "p", arg: 1, scope: !4, file: !2, line: 18, type: !1)
+!6 = !DILocation(line: 18, column: 1, scope: !4)
+!7 = !DILocation(line: 19, column: 10, scope: !4)
+!9 = distinct !DISubprogram(name: "setElem", scope: !2, file: !2, line: 16, type: !8, scopeLine: 16, spFlags: DISPFlagDefinition, unit: !3)
+!10 = !DILocation(line: 16, column: 3, scope: !9, inlinedAt: !7)
+!11 = !DIFile(filename: "system.nim", directory: "<dir>")
+!12 = distinct !DISubprogram(name: "[]=", scope: !11, file: !11, line: 34, type: !8, scopeLine: 34, spFlags: DISPFlagDefinition, unit: !3)
+!13 = !DILocation(line: 34, column: 10, scope: !12, inlinedAt: !10)
+!14 = !DILocation(line: 20, column: 10, scope: !4)
+!15 = !DILocation(line: 16, column: 3, scope: !9, inlinedAt: !14)
+!16 = !DILocation(line: 34, column: 10, scope: !12, inlinedAt: !15)
+!19 = !DILocation(line: 18, column: 1, scope: !4)
+!23 = distinct !DISubprogram(name: "X60Qini_0_<mod>", scope: !2, file: !2, line: 15, type: !30, scopeLine: 15, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !31)
+!24 = !DILocation(line: 15, column: 1, scope: !23)
+!25 = !DILocation(line: 15, column: 1, scope: !23)
+!26 = !DILocation(line: 15, column: 1, scope: !23)
+!27 = !DILocation(line: 15, column: 1, scope: !23)
+!28 = !DILocation(line: 15, column: 1, scope: !23)
+!29 = !DILocation(line: 15, column: 1, scope: !23)
+!32 = !DILocation(line: 15, column: 1, scope: !23)
+!51 = distinct !DISubprogram(name: "main", scope: !2, file: !2, line: 15, type: !64, scopeLine: 15, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !65)
+!52 = !DILocalVariable(name: "`argc", arg: 1, scope: !51, file: !2, line: 15, type: !33)
+!53 = !DILocation(line: 15, column: 1, scope: !51)
+!54 = !DILocalVariable(name: "`argv", arg: 2, scope: !51, file: !2, line: 15, type: !48)
+!55 = !DILocation(line: 15, column: 1, scope: !51)
+!56 = !DILocalVariable(name: "`envp", arg: 3, scope: !51, file: !2, line: 15, type: !50)
+!57 = !DILocation(line: 15, column: 1, scope: !51)
+!58 = !DILocation(line: 15, column: 1, scope: !51)
+!59 = !DILocation(line: 15, column: 1, scope: !51)
+!60 = !DILocation(line: 15, column: 1, scope: !51)
+!61 = !DILocation(line: 15, column: 1, scope: !51)
+!62 = !DILocation(line: 15, column: 1, scope: !51)
+!63 = !DILocation(line: 15, column: 1, scope: !51)
diff --git a/tests/llvmdebug/ttemplate_frames.nim b/tests/llvmdebug/ttemplate_frames.nim
new file mode 100644
index 000000000..9ffcf87e5
--- /dev/null
+++ b/tests/llvmdebug/ttemplate_frames.nim
@@ -0,0 +1,20 @@
+# Regression guard for nim-lang/nimony#1987: a template call must appear as an
+# inlined stack frame, not as a jump into the template's definition.
+#
+# Before the fix, stepping over `setElem(p, 0, 'H')` in lldb landed on
+# `system.nim:34` (the body of `[]=`) with a bare
+#     !DILocation(line: 34, column: 10, scope: !<the caller>)
+# and no `inlinedAt`, so the debugger had no frame to attribute it to.
+#
+# The golden below pins the shape that fixes it: one DISubprogram per expanded
+# template, and every location inside it chained back to its call site through
+# `inlinedAt`. `setElem` expands `[]=`, so the chain is two levels deep — that
+# nesting is the part most likely to regress (building the call-site location
+# after pushing the frame would silently flatten it).
+
+template setElem(x: ptr UncheckedArray[char]; i: int; elem: char) =
+  x[i] = elem
+
+proc run(p: ptr UncheckedArray[char]) {.exportc.} =
+  setElem(p, 0, 'H')
+  setElem(p, 1, 'i')
diff --git a/tests/llvmdebug/ttemplate_locals.ll.expected b/tests/llvmdebug/ttemplate_locals.ll.expected
new file mode 100644
index 000000000..07405d459
--- /dev/null
+++ b/tests/llvmdebug/ttemplate_locals.ll.expected
@@ -0,0 +1,35 @@
+!3 = !DIFile(filename: "ttemplate_locals.nim", directory: "<dir>")
+!5 = distinct !DISubprogram(name: "run2", scope: !3, file: !3, line: 15, type: !18, scopeLine: 15, spFlags: DISPFlagDefinition, unit: !4, retainedNodes: !19)
+!6 = !DILocalVariable(name: "x", arg: 1, scope: !5, file: !3, line: 15, type: !1)
+!7 = !DILocation(line: 15, column: 1, scope: !5)
+!8 = !DILocalVariable(name: "y", arg: 2, scope: !5, file: !3, line: 15, type: !2)
+!9 = !DILocation(line: 15, column: 1, scope: !5)
+!10 = !DILocation(line: 16, column: 11, scope: !5)
+!12 = distinct !DISubprogram(name: "withTemp", scope: !3, file: !3, line: 11, type: !11, scopeLine: 11, spFlags: DISPFlagDefinition, unit: !4)
+!13 = !DILocalVariable(name: "t", scope: !12, file: !3, line: 11, type: !2)
+!14 = !DILocation(line: 11, column: 7, scope: !12, inlinedAt: !10)
+!15 = !DILocation(line: 11, column: 7, scope: !12, inlinedAt: !10)
+!16 = !DILocation(line: 12, column: 5, scope: !12, inlinedAt: !10)
+!17 = !DILocation(line: 13, column: 5, scope: !12, inlinedAt: !10)
+!20 = !DILocation(line: 15, column: 1, scope: !5)
+!24 = distinct !DISubprogram(name: "X60Qini_0_<mod>", scope: !3, file: !3, line: 10, type: !31, scopeLine: 10, spFlags: DISPFlagDefinition, unit: !4, retainedNodes: !32)
+!25 = !DILocation(line: 10, column: 1, scope: !24)
+!26 = !DILocation(line: 10, column: 1, scope: !24)
+!27 = !DILocation(line: 10, column: 1, scope: !24)
+!28 = !DILocation(line: 10, column: 1, scope: !24)
+!29 = !DILocation(line: 10, column: 1, scope: !24)
+!30 = !DILocation(line: 10, column: 1, scope: !24)
+!33 = !DILocation(line: 10, column: 1, scope: !24)
+!52 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 10, type: !65, scopeLine: 10, spFlags: DISPFlagDefinition, unit: !4, retainedNodes: !66)
+!53 = !DILocalVariable(name: "`argc", arg: 1, scope: !52, file: !3, line: 10, type: !34)
+!54 = !DILocation(line: 10, column: 1, scope: !52)
+!55 = !DILocalVariable(name: "`argv", arg: 2, scope: !52, file: !3, line: 10, type: !49)
+!56 = !DILocation(line: 10, column: 1, scope: !52)
+!57 = !DILocalVariable(name: "`envp", arg: 3, scope: !52, file: !3, line: 10, type: !51)
+!58 = !DILocation(line: 10, column: 1, scope: !52)
+!59 = !DILocation(line: 10, column: 1, scope: !52)
+!60 = !DILocation(line: 10, column: 1, scope: !52)
+!61 = !DILocation(line: 10, column: 1, scope: !52)
+!62 = !DILocation(line: 10, column: 1, scope: !52)
+!63 = !DILocation(line: 10, column: 1, scope: !52)
+!64 = !DILocation(line: 10, column: 1, scope: !52)
diff --git a/tests/llvmdebug/ttemplate_locals.nim b/tests/llvmdebug/ttemplate_locals.nim
new file mode 100644
index 000000000..f11244f92
--- /dev/null
+++ b/tests/llvmdebug/ttemplate_locals.nim
@@ -0,0 +1,16 @@
+# Companion to ttemplate_frames.nim for nim-lang/nimony#1987: a variable
+# *declared inside* a template expansion.
+#
+# `#dbg_declare` names both a DILocalVariable scope and a DILocation scope.
+# Under an active inlined frame both must be the template's synthetic
+# DISubprogram and the location must carry the same `inlinedAt` chain — LLVM's
+# verifier rejects the module when they disagree. `template t = (var x = ...)`
+# is ordinary code, so this is a correctness requirement, not polish.
+
+template withTemp(a: int; b: int) =
+  var t: int = a
+  t = t + b
+  a = t
+
+proc run2(x: var int; y: int) {.exportc.} =
+  withTemp(x, y)
diff --git a/tests/nimony/nosystem/tresemtype.nif b/tests/nimony/nosystem/tresemtype.nif
index 7b6da2692..43bf54c99 100644
--- a/tests/nimony/nosystem/tresemtype.nif
+++ b/tests/nimony/nosystem/tresemtype.nif
@@ -1,5 +1,5 @@
 (.nif27)
-(.indexat 1858             )
+(.indexat 1935             )
 (stmts@,3,tests/nimony/nosystem/tresemtype.nim
  (proc :foo.0.@5 . .
   (typevars@8
@@ -27,23 +27,25 @@
    (var@4,2 :obj.1 . . Foo.1.@6
     (oconstr@9 Foo.1.~3
      (kv@4 val.0~3 x.1@2)))))
- (stmts@2,9
-  (type@9 :Foo.2.~4 . .
-   (pragmas)
-   (object@2 .
-    (fld~9,1 :val.0 . .
-     (i 64).)))
-  (gvar@4,2 :obj.2 . . Foo.2.@6
-   (oconstr@9 Foo.2.~3
-    (kv@4 val.0~3 123~A,2))))
- (stmts@2,9
-  (type@9 :Foo.3.~4 . .
-   (pragmas)
-   (object@2 .
-    (fld~9,1 :val.1 . . string.0.sysvq0asl .)))
-  (gvar@4,2 :obj.3 . . Foo.3.@6
-   (oconstr@9 Foo.3.~3
-    (kv@4 val.1~3 "abc"~A,3))))
+ (comesfrom@8,D fooTempl.0.
+  (stmts~6,~4
+   (type@9 :Foo.2.~4 . .
+    (pragmas)
+    (object@2 .
+     (fld~9,1 :val.0 . .
+      (i 64).)))
+   (gvar@4,2 :obj.2 . . Foo.2.@6
+    (oconstr@9 Foo.2.~3
+     (kv@4 val.0~3 123~A,2)))))
+ (comesfrom@8,E fooTempl.0.
+  (stmts~6,~5
+   (type@9 :Foo.3.~4 . .
+    (pragmas)
+    (object@2 .
+     (fld~9,1 :val.1 . . string.0.sysvq0asl .)))
+   (gvar@4,2 :obj.3 . . Foo.3.@6
+    (oconstr@9 Foo.3.~3
+     (kv@4 val.1~3 "abc"~A,3)))))
  (comment@8,D fooTempl.0. fooTempl.0.@,1)
  (proc@3,5 :foo.0.Imj9rno. . .~3,~5
   (at foo.0.
@@ -78,9 +80,9 @@
  (h fooTempl.0. 232)
  (h@H,8 T.1. 47)
  (h@2,9 Foo.1. 92)
- (h@2,9 Foo.2. 178)
- (h@2,9 Foo.3. 189)
- (h foo.0.Imj9rno. 229)
+ (h@2,9 Foo.2. 208)
+ (h@2,9 Foo.3. 228)
+ (h foo.0.Imj9rno. 237)
  (h@2,1 Foo.4. 144)
  (h foo.0.Iwjalau. 183)
  (h@2,1 Foo.5. 162))
\ No newline at end of file
diff --git a/tests/nimony/nosystem/tvarargs.nif b/tests/nimony/nosystem/tvarargs.nif
index 16495178c..f97ad27c0 100644
--- a/tests/nimony/nosystem/tvarargs.nif
+++ b/tests/nimony/nosystem/tvarargs.nif
@@ -1,5 +1,5 @@
 (.nif27)
-(.indexat 3622             )
+(.indexat 3753             )
 (stmts@,2,tests/nimony/nosystem/tvarargs.nim
  (type@2,1 :int.0.
   (i 64).
@@ -130,36 +130,40 @@
       (ochoice write.0. write.1.)stdout.0.@6 x.4@E)))
    (cmd@,2 write.0. stdout.0.@6 '\0A'@E)))
  (gvar@4,c :someVar.0. . . string.0.sysvq0asl ""@A)
- (stmts@2,Y
-  (stmts@2,1
-   (cmd write.1.
-    (haddr@6 stdout.0.)"a"@1,5))
-  (stmts@2,1
-   (cmd write.1.
-    (haddr@6 stdout.0.)someVar.0.@6,5))
-  (stmts@2,1
-   (cmd write.1.
-    (haddr@6 stdout.0.)"b"@F,5))
-  (cmd@,2 write.0.
-   (haddr@6 stdout.0.)'\0A'@E))
- (stmts@2,Y
-  (stmts@2,1
-   (cmd write.1.
-    (haddr@6 stdout.0.)"xzy"@1,7))
-  (stmts@2,1
-   (cmd write.0.
-    (haddr@6 stdout.0.)'c'@8,7))
-  (cmd@,2 write.0.
-   (haddr@6 stdout.0.)'\0A'@E))
- (stmts@2,Y
-  (cmd@,2 write.0.
-   (haddr@6 stdout.0.)'\0A'@E))
- (stmts@2,Y
-  (stmts@2,1
-   (cmd write.1.
-    (haddr@6 stdout.0.)someVar.0.@1,B))
-  (cmd@,2 write.0.
-   (haddr@6 stdout.0.)'\0A'@E))
+ (comesfrom@,e echo.0.
+  (stmts@2,~6
+   (stmts@2,1
+    (cmd write.1.
+     (haddr@6 stdout.0.)"a"@1,5))
+   (stmts@2,1
+    (cmd write.1.
+     (haddr@6 stdout.0.)someVar.0.@6,5))
+   (stmts@2,1
+    (cmd write.1.
+     (haddr@6 stdout.0.)"b"@F,5))
+   (cmd@,2 write.0.
+    (haddr@6 stdout.0.)'\0A'@E)))
+ (comesfrom@,g echo.0.
+  (stmts@2,~8
+   (stmts@2,1
+    (cmd write.1.
+     (haddr@6 stdout.0.)"xzy"@1,7))
+   (stmts@2,1
+    (cmd write.0.
+     (haddr@6 stdout.0.)'c'@8,7))
+   (cmd@,2 write.0.
+    (haddr@6 stdout.0.)'\0A'@E)))
+ (comesfrom@4,i echo.0.
+  (stmts~2,~A
+   (cmd@,2 write.0.
+    (haddr@6 stdout.0.)'\0A'@E)))
+ (comesfrom@,k echo.0.
+  (stmts@2,~C
+   (stmts@2,1
+    (cmd write.1.
+     (haddr@6 stdout.0.)someVar.0.@1,B))
+   (cmd@,2 write.0.
+    (haddr@6 stdout.0.)'\0A'@E)))
  (comment@F,B untyped.0. typedesc.0.@I int.0.@1,5 int.0.@1,5 int.0.~2,5 int.0.@1,6 int.0.@1,6 int.0.~2,6 int.0.@2,8 int.0.@2,8 bool.0.~2,8 char.0.@C,F untyped.0.~B,K echo.0.~F,T echo.0.~F,V echo.0.~B,X echo.0.~F,Z))(.index@,2,tests/nimony/nosystem/tvarargs.nim
  (x int.0. 82)
  (x bool.0. 64)