From f0adb3c2718b93fb17ef0473fce4024057824d13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Thu, 21 May 2026 23:03:01 +0200
Subject: [PATCH 1/9] resolve re-yielded block-param curried sub-components
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`<G.Legend>` where the parent re-yields `{{yield (hash Legend=F.Legend)}}`
from a nested `<Binder as |F|>` did not resolve: resolveBinding treated
`F.Legend` as a bare name (`resolveByName('F')`), ignoring the `.Legend`
tail and that `F` is a block param. So it fell back to the binder's
`<fieldset>` Element type (cross-package) or transparent (local) instead
of `<legend>` — the substituted `<fieldset>` looked legend-less and
wcag/h71 ("fieldset must have a legend as first child") FP-fired ~74x
across HDS, plus ~17 fieldset element-permitted-content FPs.

Add resolveBlockParamReyield: find the `<Binder as |F|>` that introduces
the block param, resolve Binder's source, and recurse into ITS yielded
hash key. Single-level yield-hash already worked; this handles the
multi-level re-yield (HdsFormCheckboxGroup → HdsFormFieldset → legend).
Verified on real HDS: <G.Legend> → <legend>, h71 no longer fires.
---
 lib/resolver/walk.ts                          | 77 +++++++++++++++++++
 .../glint-fixtures/fieldset-group-reyield.gts | 30 ++++++++
 test/glint.test.ts                            | 19 +++++
 3 files changed, 126 insertions(+)
 create mode 100644 test/glint-fixtures/fieldset-group-reyield.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index a613a7b..c719bfc 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -904,6 +904,76 @@ export function resolveYieldHashBinding(opts: YieldHashBindingOptions): Resoluti
   });
 }
 
+// Resolve a re-yielded block-param hash entry: `{{yield (hash
+// Legend=F.Legend)}}` where `F` is a block param from `<Binder as |F|>`
+// in this same template. The yielded sub-component is whatever `Binder`
+// itself yields under `Legend`, so resolve `Binder`'s source and recurse
+// into its yield-hash. Mirrors HDS's `HdsFormCheckboxGroup` re-yielding
+// `HdsFormFieldset`'s `F.Legend` — without this `<G.Legend>` fell back to
+// the binder's `<fieldset>` Element type and FP-fired `wcag/h71`.
+function resolveBlockParamReyield(
+  paramName: string,
+  hashKey: string,
+  parentSource: TemplateSource,
+  options: ResolveOptions,
+): Resolution {
+  const depth = options.depth ?? 0;
+  if (depth >= MAX_DEPTH) return TRANSPARENT;
+  let ast: AST.Template;
+  try {
+    ast = parseTemplate(parentSource.content);
+  } catch {
+    return TRANSPARENT;
+  }
+  const binderTag = findBlockParamBinder(ast, paramName);
+  if (!binderTag) return TRANSPARENT;
+
+  const importedFile = resolveImport(parentSource.origin, binderTag, options.ts ?? null);
+  let binderSource: TemplateSource | null = importedFile
+    ? findTemplateSource({ declFile: importedFile, ts: options.ts ?? null })
+    : null;
+  if (!binderSource) {
+    binderSource = findTemplateSource({
+      declFile: parentSource.origin,
+      componentName: binderTag,
+      ts: options.ts ?? null,
+    });
+  }
+  if (!binderSource) return TRANSPARENT;
+
+  return resolveYieldHashBinding({
+    parentSource: binderSource,
+    hashKey,
+    parentArgs: options.consumerArgs ?? new Map(),
+    ts: options.ts ?? null,
+    visited: options.visited,
+    depth: depth + 1,
+  });
+}
+
+// Find the PascalCase element that introduces block param `paramName`
+// via `<Tag as |…paramName…|>`, returning its tag name.
+function findBlockParamBinder(ast: AST.Template, paramName: string): string | null {
+  let result: string | null = null;
+  function visit(node: AST.Node): void {
+    if (result) return;
+    if (node.type === 'ElementNode') {
+      if (/^[A-Z]/.test(node.tag) && node.blockParams.includes(paramName)) {
+        result = node.tag;
+        return;
+      }
+      for (const child of node.children) visit(child);
+    } else if (node.type === 'BlockStatement') {
+      for (const child of node.program.body) visit(child);
+      if (node.inverse) for (const child of node.inverse.body) visit(child);
+    } else if (node.type === 'Template') {
+      for (const child of node.body) visit(child);
+    }
+  }
+  visit(ast);
+  return result;
+}
+
 // Like `resolveYieldHashBinding` but returns the underlying
 // `TemplateSource` (plus any curried `@arg` additions from a
 // `(component Inner …)` wrapper) instead of the leaf `Resolution`.
@@ -1061,6 +1131,13 @@ function resolveBinding(
   if (!expr.head) return TRANSPARENT;
 
   if (expr.head.type === 'VarHead') {
+    // `F.Legend` — `F` is a block param introduced by `<Binder as |F|>`
+    // in THIS template, so the yielded sub-component is whatever Binder
+    // re-yields under `Legend`. (A bare `Foo` with no tail is a local
+    // import / in-scope component → resolveByName.)
+    if (expr.tail.length > 0) {
+      return resolveBlockParamReyield(expr.head.name, expr.tail[0]!, parentSource, options);
+    }
     return resolveByName(expr.head.name, parentSource, options);
   }
 
diff --git a/test/glint-fixtures/fieldset-group-reyield.gts b/test/glint-fixtures/fieldset-group-reyield.gts
new file mode 100644
index 0000000..2de1511
--- /dev/null
+++ b/test/glint-fixtures/fieldset-group-reyield.gts
@@ -0,0 +1,30 @@
+import Component from '@glimmer/component';
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+interface LegendSig { Element: HTMLLegendElement; Blocks: { default: [] } }
+const Legend: TOC<LegendSig> = <template><legend ...attributes>{{yield}}</legend></template>;
+
+interface InnerSig { Element: HTMLFieldSetElement; Blocks: { default: [{ Legend: typeof Legend }] } }
+class InnerFieldset extends Component<InnerSig> {
+  Legend = Legend;
+  <template><fieldset ...attributes>{{yield (hash Legend=this.Legend)}}</fieldset></template>
+}
+
+// Re-yields F.Legend (the nested fieldset's yielded sub-component) —
+// mirrors HdsFormCheckboxGroup re-yielding HdsFormFieldset's F.Legend.
+interface OuterSig { Element: HTMLFieldSetElement; Blocks: { default: [{ Legend: typeof Legend }] } }
+class OuterGroup extends Component<OuterSig> {
+  <template>
+    <InnerFieldset as |F|>
+      {{yield (hash Legend=F.Legend)}}
+    </InnerFieldset>
+  </template>
+}
+
+<template>
+  <OuterGroup as |G|>
+    <G.Legend>Group legend</G.Legend>
+    <input type="checkbox" />
+  </OuterGroup>
+</template>
diff --git a/test/glint.test.ts b/test/glint.test.ts
index 7299af7..01c8f76 100644
--- a/test/glint.test.ts
+++ b/test/glint.test.ts
@@ -397,6 +397,25 @@ describe('Glint integration: cross-file .gts type resolution', () => {
     ).toBeDefined();
   });
 
+  it('resolves a RE-YIELDED curried sub-component through the chain (group → fieldset → legend)', () => {
+    // HdsFormCheckboxGroup shape: the group renders `<HdsFormFieldset as
+    // |F|>` and re-yields `{{yield (hash Legend=F.Legend)}}`, so
+    // `<G.Legend>` chains through the nested fieldset's yielded Legend to
+    // `<legend>`. Single-level yield-hash (yielded-curried-component.gts)
+    // already resolves; this multi-level RE-YIELD did not — `<G.Legend>`
+    // fell back to the binder's `<fieldset>` Element type (cross-package)
+    // / transparent (local) instead of `<legend>`, so the substituted
+    // `<fieldset>` looked legend-less and `wcag/h71` ("fieldset must have
+    // a legend as first child") FP-fired ~74× across HDS.
+    const { filename, contents } = readFixture('fieldset-group-reyield.gts');
+    const { componentTagMap } = extractAttrTypeMap(filename, contents)!;
+    const tags = [...componentTagMap.values()];
+    expect(
+      tags.includes('legend'),
+      `<G.Legend> must resolve to <legend> through the re-yield chain; got: ${JSON.stringify([...componentTagMap.entries()])}`,
+    ).toBe(true);
+  });
+
   it('does not crash when the imported .gts does not exist', () => {
     // Negative-path: the shim's path-existence check has to fail gracefully
     // rather than throwing. broken-import.gts imports './does-not-exist.gts'

From 8d1d5a840d815c3dd503f2cb57c6424e9d15eee5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Thu, 21 May 2026 23:35:48 +0200
Subject: [PATCH 2/9] re-yield: pass binder's own @args; restrict binder to
 PascalCase

Two fixes from Copilot review on #45:
- resolveBlockParamReyield passed the OUTER component's consumerArgs as
  parentArgs when recursing into the binder. The binder is invoked here
  (`<Binder @x="y" as |F|>`), so @arg-driven yield-hash entries must see
  the args passed at THIS site. Collect the binder element's literal
  @arg="lit" and @arg={{@caller}} passthrough instead.
- findBlockParamBinder matched any `/^[A-Z]/` tag, including dotted
  (`F.Foo`) / colon tags that resolveImport/by-name can't resolve (only
  yielding a useless TRANSPARENT). Restrict to `/^[A-Z][A-Za-z0-9]*$/`
  and return the element node (needed for the @arg collection above).
---
 lib/resolver/walk.ts | 43 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 34 insertions(+), 9 deletions(-)

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index c719bfc..82fadb0 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -925,8 +925,30 @@ function resolveBlockParamReyield(
   } catch {
     return TRANSPARENT;
   }
-  const binderTag = findBlockParamBinder(ast, paramName);
-  if (!binderTag) return TRANSPARENT;
+  const binderNode = findBlockParamBinder(ast, paramName);
+  if (!binderNode) return TRANSPARENT;
+  const binderTag = binderNode.tag;
+
+  // The binder is invoked WITHIN this template (`<Binder @x="y" as |F|>`),
+  // so any `@arg`-driven yield-hash entry inside Binder must resolve
+  // against the args passed HERE — not the outer component's consumer
+  // args. Collect literal `@arg="lit"` and `@arg={{@caller}}` passthrough.
+  const binderArgs = new Map<string, string>();
+  for (const attr of binderNode.attributes) {
+    if (!attr.name.startsWith('@')) continue;
+    const argName = attr.name.slice(1);
+    if (attr.value.type === 'TextNode') {
+      binderArgs.set(argName, attr.value.chars);
+    } else if (
+      attr.value.type === 'MustacheStatement'
+      && attr.value.path.type === 'PathExpression'
+      && attr.value.path.head?.type === 'AtHead'
+    ) {
+      const caller = attr.value.path.head.name.replace(/^@/, '');
+      const v = options.consumerArgs?.get(caller);
+      if (v !== undefined) binderArgs.set(argName, v);
+    }
+  }
 
   const importedFile = resolveImport(parentSource.origin, binderTag, options.ts ?? null);
   let binderSource: TemplateSource | null = importedFile
@@ -944,22 +966,25 @@ function resolveBlockParamReyield(
   return resolveYieldHashBinding({
     parentSource: binderSource,
     hashKey,
-    parentArgs: options.consumerArgs ?? new Map(),
+    parentArgs: binderArgs,
     ts: options.ts ?? null,
     visited: options.visited,
     depth: depth + 1,
   });
 }
 
-// Find the PascalCase element that introduces block param `paramName`
-// via `<Tag as |…paramName…|>`, returning its tag name.
-function findBlockParamBinder(ast: AST.Template, paramName: string): string | null {
-  let result: string | null = null;
+// Find the element that introduces block param `paramName` via
+// `<Tag as |…paramName…|>`, returning the element node. Restricted to
+// resolvable PascalCase tags (`/^[A-Z][A-Za-z0-9]*$/`): dotted (`F.Foo`)
+// and colon (`:slot`) tags can't be resolved via import/by-name, so
+// matching them would only yield a useless TRANSPARENT.
+function findBlockParamBinder(ast: AST.Template, paramName: string): AST.ElementNode | null {
+  let result: AST.ElementNode | null = null;
   function visit(node: AST.Node): void {
     if (result) return;
     if (node.type === 'ElementNode') {
-      if (/^[A-Z]/.test(node.tag) && node.blockParams.includes(paramName)) {
-        result = node.tag;
+      if (/^[A-Z][A-Za-z0-9]*$/.test(node.tag) && node.blockParams.includes(paramName)) {
+        result = node;
         return;
       }
       for (const child of node.children) visit(child);

From fc051ba68e6776982a04d3c41d37846b3d77d2aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Thu, 21 May 2026 23:46:43 +0200
Subject: [PATCH 3/9] re-yield: broaden binder lookup; fall back to
 resolveByName for non-block-param dotted bindings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

resolveBlockParamReyield now mirrors resolvePascalRecursion's full
lookup order (import, same-file decl, by-name/classic, sibling probe)
so re-yield chains resolve under .hbs and sibling-file consumers too.

It also returns null when the head is not a block param introduced in
this template, letting resolveBinding fall back to resolveByName(head) —
restoring pre-re-yield behavior for plain VarHead+tail property access
instead of bailing TRANSPARENT.
---
 lib/resolver/walk.ts                          | 39 +++++++++++++++----
 .../dotted-nonblockparam-binding.gts          | 15 +++++++
 test/resolver/walk.test.ts                    | 22 +++++++++++
 3 files changed, 69 insertions(+), 7 deletions(-)
 create mode 100644 test/glint-fixtures/dotted-nonblockparam-binding.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index 82fadb0..eef3bc1 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -911,12 +911,17 @@ export function resolveYieldHashBinding(opts: YieldHashBindingOptions): Resoluti
 // into its yield-hash. Mirrors HDS's `HdsFormCheckboxGroup` re-yielding
 // `HdsFormFieldset`'s `F.Legend` — without this `<G.Legend>` fell back to
 // the binder's `<fieldset>` Element type and FP-fired `wcag/h71`.
+// Returns `null` (rather than TRANSPARENT) when `paramName` is not a
+// block param introduced in this template — i.e. the `VarHead`+tail was
+// general property access, not a re-yield. The caller then falls back to
+// the prior `resolveByName(head)` behavior. A binder that IS found but
+// fails to resolve still returns TRANSPARENT (the FP-safe answer).
 function resolveBlockParamReyield(
   paramName: string,
   hashKey: string,
   parentSource: TemplateSource,
   options: ResolveOptions,
-): Resolution {
+): Resolution | null {
   const depth = options.depth ?? 0;
   if (depth >= MAX_DEPTH) return TRANSPARENT;
   let ast: AST.Template;
@@ -926,7 +931,7 @@ function resolveBlockParamReyield(
     return TRANSPARENT;
   }
   const binderNode = findBlockParamBinder(ast, paramName);
-  if (!binderNode) return TRANSPARENT;
+  if (!binderNode) return null;
   const binderTag = binderNode.tag;
 
   // The binder is invoked WITHIN this template (`<Binder @x="y" as |F|>`),
@@ -950,6 +955,12 @@ function resolveBlockParamReyield(
     }
   }
 
+  // Resolve the binder's source, mirroring `resolvePascalRecursion`'s
+  // lookup order so re-yield chains resolve under every consumer style:
+  //   1. `import Binder from '...'` in this template's origin.
+  //   2. Same-file declaration (`const Binder = <template>…` in this .gts).
+  //   3. v1-addon by-name resolution (`.hbs` consumers — no imports).
+  //   4. Sibling-file probe (same dir as origin) as a last resort.
   const importedFile = resolveImport(parentSource.origin, binderTag, options.ts ?? null);
   let binderSource: TemplateSource | null = importedFile
     ? findTemplateSource({ declFile: importedFile, ts: options.ts ?? null })
@@ -961,6 +972,16 @@ function resolveBlockParamReyield(
       ts: options.ts ?? null,
     });
   }
+  if (!binderSource) {
+    binderSource = findTemplateSource({
+      consumerFile: parentSource.origin,
+      componentName: binderTag,
+      ts: options.ts ?? null,
+    });
+  }
+  if (!binderSource) {
+    binderSource = trySiblingProbe(parentSource.origin, binderTag);
+  }
   if (!binderSource) return TRANSPARENT;
 
   return resolveYieldHashBinding({
@@ -1156,12 +1177,16 @@ function resolveBinding(
   if (!expr.head) return TRANSPARENT;
 
   if (expr.head.type === 'VarHead') {
-    // `F.Legend` — `F` is a block param introduced by `<Binder as |F|>`
-    // in THIS template, so the yielded sub-component is whatever Binder
-    // re-yields under `Legend`. (A bare `Foo` with no tail is a local
-    // import / in-scope component → resolveByName.)
+    // `F.Legend` — when `F` is a block param introduced by `<Binder as
+    // |F|>` in THIS template, the yielded sub-component is whatever Binder
+    // re-yields under `Legend`. But `VarHead`+tail is also the general
+    // shape for property access on any in-scope value; when `F` is not a
+    // block param, `resolveBlockParamReyield` returns null and we fall
+    // back to resolving the head name directly (the prior behavior).
+    // (A bare `Foo` with no tail is a local import / in-scope component.)
     if (expr.tail.length > 0) {
-      return resolveBlockParamReyield(expr.head.name, expr.tail[0]!, parentSource, options);
+      const reyield = resolveBlockParamReyield(expr.head.name, expr.tail[0]!, parentSource, options);
+      if (reyield !== null) return reyield;
     }
     return resolveByName(expr.head.name, parentSource, options);
   }
diff --git a/test/glint-fixtures/dotted-nonblockparam-binding.gts b/test/glint-fixtures/dotted-nonblockparam-binding.gts
new file mode 100644
index 0000000..dba23be
--- /dev/null
+++ b/test/glint-fixtures/dotted-nonblockparam-binding.gts
@@ -0,0 +1,15 @@
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+// `NavList` is an in-scope const component, NOT a block param introduced
+// via `<… as |NavList|>`. A hash entry `NavList.Item` is therefore plain
+// property access, not a block-param re-yield: `resolveBlockParamReyield`
+// must find no binder and the caller must fall back to resolving the head
+// (`NavList`) by name — landing on `<nav>` rather than TRANSPARENT.
+interface NavSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Item: unknown }] };
+}
+const NavList: TOC<NavSig> = <template>
+  <nav ...attributes>{{yield (hash Item="x")}}</nav>
+</template>;
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 8b82800..322af98 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -235,4 +235,26 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('div');
   });
+
+  test('VarHead+tail whose head is NOT a block param falls back to resolveByName', async () => {
+    // `NavList.Item` is property access on an in-scope const, not a
+    // block-param re-yield (`NavList` is never bound via `as |NavList|`).
+    // `resolveBlockParamReyield` returns null for the missing binder, so
+    // the caller falls back to resolving the head (`NavList`) by name —
+    // restoring the pre-re-yield behavior instead of bailing TRANSPARENT.
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'dotted-nonblockparam-binding.gts');
+    const r = resolveYieldHashBinding({
+      parentSource: {
+        content: `{{yield (hash Thing=NavList.Item)}}`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Thing',
+      parentArgs: new Map(),
+      ts,
+    });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('nav');
+  });
 });

From 81d3abb8eb76353d9011228100426515668f1825 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 22 May 2026 00:04:45 +0200
Subject: [PATCH 4/9] re-yield: resolve binder @arg={{this.prop}} via class
 getter

binderArgs collection only handled @arg="literal" and @arg={{@caller}}
passthrough. Mirror resolvePascalRecursionWith and also resolve
@arg={{this.prop}} through the re-yielding component's class getter
(resolveThisProp), so re-yield chains whose binder hash depends on a
class-derived arg resolve instead of bailing TRANSPARENT.
---
 lib/resolver/walk.ts                          | 22 ++++++++++----
 .../reyield-binder-thisprop-arg.gts           | 29 +++++++++++++++++++
 test/resolver/walk.test.ts                    | 22 ++++++++++++++
 3 files changed, 68 insertions(+), 5 deletions(-)
 create mode 100644 test/glint-fixtures/reyield-binder-thisprop-arg.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index eef3bc1..71dccf6 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -937,7 +937,11 @@ function resolveBlockParamReyield(
   // The binder is invoked WITHIN this template (`<Binder @x="y" as |F|>`),
   // so any `@arg`-driven yield-hash entry inside Binder must resolve
   // against the args passed HERE — not the outer component's consumer
-  // args. Collect literal `@arg="lit"` and `@arg={{@caller}}` passthrough.
+  // args. Collect:
+  //   - literal `@arg="lit"`,
+  //   - `@arg={{@caller}}` passthrough (look up in this component's args),
+  //   - `@arg={{this.prop}}` class-derived literal (walk this component's
+  //     getter, mirroring `resolvePascalRecursionWith`).
   const binderArgs = new Map<string, string>();
   for (const attr of binderNode.attributes) {
     if (!attr.name.startsWith('@')) continue;
@@ -947,11 +951,19 @@ function resolveBlockParamReyield(
     } else if (
       attr.value.type === 'MustacheStatement'
       && attr.value.path.type === 'PathExpression'
-      && attr.value.path.head?.type === 'AtHead'
     ) {
-      const caller = attr.value.path.head.name.replace(/^@/, '');
-      const v = options.consumerArgs?.get(caller);
-      if (v !== undefined) binderArgs.set(argName, v);
+      const expr = attr.value.path;
+      if (expr.head?.type === 'AtHead') {
+        const caller = expr.head.name.replace(/^@/, '');
+        const v = options.consumerArgs?.get(caller);
+        if (v !== undefined) binderArgs.set(argName, v);
+      } else if (expr.head?.type === 'ThisHead') {
+        const propName = expr.tail[0];
+        if (propName && options.ts) {
+          const v = resolveThisProp(parentSource, propName, options);
+          if (v !== null) binderArgs.set(argName, v);
+        }
+      }
     }
   }
 
diff --git a/test/glint-fixtures/reyield-binder-thisprop-arg.gts b/test/glint-fixtures/reyield-binder-thisprop-arg.gts
new file mode 100644
index 0000000..a58783f
--- /dev/null
+++ b/test/glint-fixtures/reyield-binder-thisprop-arg.gts
@@ -0,0 +1,29 @@
+import Component from '@glimmer/component';
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+// The binder's yielded hash entry is driven by an `@arg` (`@elementTag`).
+interface BinderSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Item: unknown }] };
+}
+const Binder: TOC<BinderSig> = <template>{{yield (hash Item=@elementTag)}}</template>;
+
+// The re-yielding component passes that arg from a CLASS GETTER
+// (`@elementTag={{this.tag}}`). Resolving `Thing` (re-yielded `F.Item`)
+// requires walking `this.tag` to its literal `'section'` so the binder's
+// `@elementTag` lookup lands on `<section>` rather than TRANSPARENT.
+interface ParentSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Thing: unknown }] };
+}
+class Parent extends Component<ParentSig> {
+  get tag(): string {
+    return 'section';
+  }
+  <template>
+    <Binder @elementTag={{this.tag}} as |F|>
+      {{yield (hash Thing=F.Item)}}
+    </Binder>
+  </template>
+}
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 322af98..6da2577 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -257,4 +257,26 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('nav');
   });
+
+  test('re-yield binder @arg driven by {{this.prop}} resolves via class getter', async () => {
+    // `<Binder @elementTag={{this.tag}} as |F|>` — the binder's yielded
+    // hash entry depends on `@elementTag`, passed from the re-yielding
+    // component's class getter. `binderArgs` must resolve `this.tag` to
+    // its literal (`'section'`) — parity with `resolvePascalRecursionWith`
+    // — or the binder's `@elementTag` lookup bails TRANSPARENT.
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'reyield-binder-thisprop-arg.gts');
+    const r = resolveYieldHashBinding({
+      parentSource: {
+        content: `<Binder @elementTag={{this.tag}} as |F|>{{yield (hash Thing=F.Item)}}</Binder>`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Thing',
+      parentArgs: new Map(),
+      ts,
+    });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('section');
+  });
 });

From 1d1ccdcf41cd5b8f34b7b302ff72db3bd32d90e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 22 May 2026 00:19:41 +0200
Subject: [PATCH 5/9] re-yield: scope binder lookup to the in-scope re-yield
 reference

findBlockParamBinder returned the first element in the template whose
block params happened to include the name, which selects the wrong
binder when a short param name (F) is reused across sibling blocks or
shadowed by a nested binder. Track the element-ancestor stack and pick
the nearest enclosing <Tag as |F|> of the actual
{{yield (hash key=F.hashKey)}} reference instead.

Also declare the Args shape on the test fixture's binder signature so it
reflects a typed arg-driven binder.
---
 lib/resolver/walk.ts                          | 75 ++++++++++++++++---
 .../reyield-binder-thisprop-arg.gts           |  1 +
 .../reyield-sibling-binder-shadow.gts         | 19 +++++
 test/resolver/walk.test.ts                    | 20 +++++
 4 files changed, 105 insertions(+), 10 deletions(-)
 create mode 100644 test/glint-fixtures/reyield-sibling-binder-shadow.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index 71dccf6..c0905ee 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -930,7 +930,7 @@ function resolveBlockParamReyield(
   } catch {
     return TRANSPARENT;
   }
-  const binderNode = findBlockParamBinder(ast, paramName);
+  const binderNode = findBlockParamBinder(ast, paramName, hashKey);
   if (!binderNode) return null;
   const binderTag = binderNode.tag;
 
@@ -1006,21 +1006,76 @@ function resolveBlockParamReyield(
   });
 }
 
-// Find the element that introduces block param `paramName` via
-// `<Tag as |…paramName…|>`, returning the element node. Restricted to
-// resolvable PascalCase tags (`/^[A-Z][A-Za-z0-9]*$/`): dotted (`F.Foo`)
-// and colon (`:slot`) tags can't be resolved via import/by-name, so
-// matching them would only yield a useless TRANSPARENT.
-function findBlockParamBinder(ast: AST.Template, paramName: string): AST.ElementNode | null {
+// Find the in-scope binder for a re-yielded reference `paramName.hashKey`:
+// the NEAREST enclosing `<Tag as |…paramName…|>` ancestor of the
+// `{{yield (hash <key>=paramName.hashKey)}}` statement that produces it.
+//
+// Scoping to the actual reference — rather than returning the first
+// element in the template whose block params happen to include
+// `paramName` — keeps resolution correct when a short param name (like
+// `F`) is reused across sibling blocks or shadowed by a nested binder:
+// we track the element-ancestor stack while walking and, on reaching the
+// matching re-yield entry, pick the closest ancestor that binds the param.
+//
+// Restricted to resolvable PascalCase tags (`/^[A-Z][A-Za-z0-9]*$/`):
+// dotted (`F.Foo`) and colon (`:slot`) tags can't be resolved via
+// import/by-name, so matching them would only yield a useless TRANSPARENT.
+function findBlockParamBinder(
+  ast: AST.Template,
+  paramName: string,
+  hashKey: string,
+): AST.ElementNode | null {
+  const stack: AST.ElementNode[] = [];
+
+  // Nearest enclosing element on the stack that binds `paramName`.
+  function nearestBinder(): AST.ElementNode | null {
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const el = stack[i]!;
+      if (/^[A-Z][A-Za-z0-9]*$/.test(el.tag) && el.blockParams.includes(paramName)) {
+        return el;
+      }
+    }
+    return null;
+  }
+
+  // Is `node` a `{{yield (hash <anyKey>=paramName.hashKey)}}` re-yield
+  // entry? We match on the entry's VALUE (`paramName.hashKey` — the
+  // re-yielded reference) rather than the outer hash key it's bound
+  // under, which is arbitrary and unrelated to which binder is in scope.
+  function isReyieldEntry(node: AST.Node): boolean {
+    if (node.type !== 'MustacheStatement' && node.type !== 'SubExpression') return false;
+    const mu = node as AST.MustacheStatement | AST.SubExpression;
+    if (mu.path.type !== 'PathExpression' || mu.path.original !== 'yield') return false;
+    for (const param of mu.params) {
+      if (param.type !== 'SubExpression') continue;
+      if (param.path.type !== 'PathExpression' || param.path.original !== 'hash') continue;
+      for (const pair of param.hash.pairs) {
+        const v = pair.value;
+        if (
+          v.type === 'PathExpression'
+          && v.head?.type === 'VarHead'
+          && v.head.name === paramName
+          && v.tail[0] === hashKey
+        ) return true;
+      }
+    }
+    return false;
+  }
+
   let result: AST.ElementNode | null = null;
   function visit(node: AST.Node): void {
     if (result) return;
-    if (node.type === 'ElementNode') {
-      if (/^[A-Z][A-Za-z0-9]*$/.test(node.tag) && node.blockParams.includes(paramName)) {
-        result = node;
+    if (isReyieldEntry(node)) {
+      const binder = nearestBinder();
+      if (binder) {
+        result = binder;
         return;
       }
+    }
+    if (node.type === 'ElementNode') {
+      stack.push(node);
       for (const child of node.children) visit(child);
+      stack.pop();
     } else if (node.type === 'BlockStatement') {
       for (const child of node.program.body) visit(child);
       if (node.inverse) for (const child of node.inverse.body) visit(child);
diff --git a/test/glint-fixtures/reyield-binder-thisprop-arg.gts b/test/glint-fixtures/reyield-binder-thisprop-arg.gts
index a58783f..a65f6ba 100644
--- a/test/glint-fixtures/reyield-binder-thisprop-arg.gts
+++ b/test/glint-fixtures/reyield-binder-thisprop-arg.gts
@@ -5,6 +5,7 @@ import type { TOC } from '@ember/component/template-only';
 // The binder's yielded hash entry is driven by an `@arg` (`@elementTag`).
 interface BinderSig {
   Element: HTMLElement;
+  Args: { elementTag: string };
   Blocks: { default: [{ Item: unknown }] };
 }
 const Binder: TOC<BinderSig> = <template>{{yield (hash Item=@elementTag)}}</template>;
diff --git a/test/glint-fixtures/reyield-sibling-binder-shadow.gts b/test/glint-fixtures/reyield-sibling-binder-shadow.gts
new file mode 100644
index 0000000..95206ae
--- /dev/null
+++ b/test/glint-fixtures/reyield-sibling-binder-shadow.gts
@@ -0,0 +1,19 @@
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+interface LeafSig {
+  Element: HTMLElement;
+  Blocks: { default: [] };
+}
+const SectionLeaf: TOC<LeafSig> = <template><section ...attributes>{{yield}}</section></template>;
+const ArticleLeaf: TOC<LeafSig> = <template><article ...attributes>{{yield}}</article></template>;
+
+// Two binders, BOTH binding the short param name `F`. The re-yield
+// reference `F.Item` lives inside BinderB, so resolution must pick
+// BinderB (→ `<article>`), not the first `F` binder BinderA (→ `<section>`).
+interface BinderSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Item: unknown }] };
+}
+const BinderA: TOC<BinderSig> = <template>{{yield (hash Item=SectionLeaf)}}</template>;
+const BinderB: TOC<BinderSig> = <template>{{yield (hash Item=ArticleLeaf)}}</template>;
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 6da2577..fc49bde 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -279,4 +279,24 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('section');
   });
+
+  test('reused block-param name picks the binder enclosing the re-yield, not the first', async () => {
+    // Two sibling binders both bind `F`. The `F.Item` re-yield lives in
+    // BinderB (→ `<article>`); resolution must scope to that binder, not
+    // return the first `F`-binding element BinderA (→ `<section>`).
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'reyield-sibling-binder-shadow.gts');
+    const r = resolveYieldHashBinding({
+      parentSource: {
+        content: `<BinderA as |F|>x</BinderA><BinderB as |F|>{{yield (hash Thing=F.Item)}}</BinderB>`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Thing',
+      parentArgs: new Map(),
+      ts,
+    });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('article');
+  });
 });

From 4696407a5eeec0dcffa039cef82fc60c596e3e3d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 22 May 2026 00:30:12 +0200
Subject: [PATCH 6/9] re-yield: don't self-match parent on same-file binder
 lookup; reuse parsed AST

findTemplateSource returns a file's sole <template> regardless of the
componentName asked for (every .hbs, single-template .gts/.gjs). The
same-file binder lookup therefore returned the PARENT itself, which both
short-circuited the by-name/sibling probes and self-recursed to
MAX_DEPTH -> TRANSPARENT. Accept the same-file decl only when it selects
a different <template> block (origin+content differ from the parent).

Also thread the already-parsed parent AST from resolveYieldHashBinding
through resolveBinding into resolveBlockParamReyield instead of
re-parsing parentSource.content.
---
 lib/resolver/walk.ts                          | 28 +++++++++++--------
 .../single-template-reyield/Binder.gts        |  5 ++++
 .../single-template-reyield/Parent.gts        | 10 +++++++
 .../single-template-reyield/Sec.gts           |  1 +
 test/resolver/walk.test.ts                    | 22 +++++++++++++++
 5 files changed, 55 insertions(+), 11 deletions(-)
 create mode 100644 test/glint-fixtures/single-template-reyield/Binder.gts
 create mode 100644 test/glint-fixtures/single-template-reyield/Parent.gts
 create mode 100644 test/glint-fixtures/single-template-reyield/Sec.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index c0905ee..0b2fbf7 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -896,7 +896,7 @@ export function resolveYieldHashBinding(opts: YieldHashBindingOptions): Resoluti
   const binding = findYieldHashEntry(ast, hashKey);
   if (!binding) return TRANSPARENT;
 
-  return resolveBinding(binding, parentSource, {
+  return resolveBinding(binding, parentSource, ast, {
     consumerArgs: parentArgs,
     ts: ts ?? null,
     visited,
@@ -920,17 +920,12 @@ function resolveBlockParamReyield(
   paramName: string,
   hashKey: string,
   parentSource: TemplateSource,
+  parentAst: AST.Template,
   options: ResolveOptions,
 ): Resolution | null {
   const depth = options.depth ?? 0;
   if (depth >= MAX_DEPTH) return TRANSPARENT;
-  let ast: AST.Template;
-  try {
-    ast = parseTemplate(parentSource.content);
-  } catch {
-    return TRANSPARENT;
-  }
-  const binderNode = findBlockParamBinder(ast, paramName, hashKey);
+  const binderNode = findBlockParamBinder(parentAst, paramName, hashKey);
   if (!binderNode) return null;
   const binderTag = binderNode.tag;
 
@@ -978,11 +973,21 @@ function resolveBlockParamReyield(
     ? findTemplateSource({ declFile: importedFile, ts: options.ts ?? null })
     : null;
   if (!binderSource) {
-    binderSource = findTemplateSource({
+    const sameFile = findTemplateSource({
       declFile: parentSource.origin,
       componentName: binderTag,
       ts: options.ts ?? null,
     });
+    // `findTemplateSource` returns a file's sole `<template>` regardless
+    // of `componentName` for single-template files (every `.hbs`, many
+    // `.gts`/`.gjs`). That would be the PARENT itself — recursing on it
+    // self-matches until MAX_DEPTH → TRANSPARENT, AND short-circuits the
+    // by-name / sibling probes below. Accept the same-file decl only when
+    // it selected a DIFFERENT `<template>` block (the multi-template case
+    // where the binder really is a sibling declaration in this file).
+    if (sameFile && !(sameFile.origin === parentSource.origin && sameFile.content === parentSource.content)) {
+      binderSource = sameFile;
+    }
   }
   if (!binderSource) {
     binderSource = findTemplateSource({
@@ -1212,6 +1217,7 @@ function findYieldHashEntry(
 function resolveBinding(
   expr: AST.Expression,
   parentSource: TemplateSource,
+  parentAst: AST.Template,
   options: ResolveOptions,
 ): Resolution {
   // `Title=(component HdsFormHeaderTitle size="300")` — the hash
@@ -1234,7 +1240,7 @@ function resolveBinding(
         curriedArgs.set(pair.key, pair.value.value);
       }
     }
-    return resolveBinding(componentRef, parentSource, {
+    return resolveBinding(componentRef, parentSource, parentAst, {
       ...options,
       consumerArgs: curriedArgs,
     });
@@ -1252,7 +1258,7 @@ function resolveBinding(
     // back to resolving the head name directly (the prior behavior).
     // (A bare `Foo` with no tail is a local import / in-scope component.)
     if (expr.tail.length > 0) {
-      const reyield = resolveBlockParamReyield(expr.head.name, expr.tail[0]!, parentSource, options);
+      const reyield = resolveBlockParamReyield(expr.head.name, expr.tail[0]!, parentSource, parentAst, options);
       if (reyield !== null) return reyield;
     }
     return resolveByName(expr.head.name, parentSource, options);
diff --git a/test/glint-fixtures/single-template-reyield/Binder.gts b/test/glint-fixtures/single-template-reyield/Binder.gts
new file mode 100644
index 0000000..f91c695
--- /dev/null
+++ b/test/glint-fixtures/single-template-reyield/Binder.gts
@@ -0,0 +1,5 @@
+import Sec from './Sec.gts';
+
+// Single-`<template>` binder, resolved via sibling probe from Parent.gts.
+// Its `Item` re-yields the imported `<Sec>` (→ `<section>`).
+<template>{{yield (hash Item=Sec)}}</template>
diff --git a/test/glint-fixtures/single-template-reyield/Parent.gts b/test/glint-fixtures/single-template-reyield/Parent.gts
new file mode 100644
index 0000000..e7d855d
--- /dev/null
+++ b/test/glint-fixtures/single-template-reyield/Parent.gts
@@ -0,0 +1,10 @@
+// Single-`<template>` file: `findTemplateSource({ declFile, componentName })`
+// returns this sole template regardless of the name asked for. The binder
+// `<Binder>` is referenced WITHOUT an import (resolved via sibling probe),
+// so the same-file decl lookup must NOT self-match this parent and recurse
+// to MAX_DEPTH — it must fall through to the sibling `Binder.gts`.
+<template>
+  <Binder as |F|>
+    {{yield (hash Thing=F.Item)}}
+  </Binder>
+</template>
diff --git a/test/glint-fixtures/single-template-reyield/Sec.gts b/test/glint-fixtures/single-template-reyield/Sec.gts
new file mode 100644
index 0000000..64890dd
--- /dev/null
+++ b/test/glint-fixtures/single-template-reyield/Sec.gts
@@ -0,0 +1 @@
+<template><section ...attributes>{{yield}}</section></template>
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index fc49bde..73aaf1a 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -299,4 +299,26 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('article');
   });
+
+  test('single-template parent: binder resolves via sibling probe, not self-match', async () => {
+    // Parent.gts is a single-`<template>` file, so the same-file decl
+    // lookup returns the parent itself for any componentName. The binder
+    // `<Binder>` (no import) must instead resolve via the sibling
+    // `Binder.gts` → `<Sec>` → `<section>`, rather than self-recursing to
+    // MAX_DEPTH → TRANSPARENT. Load the parent via `findTemplateSource`
+    // (as the real pipeline does) so its content matches the file exactly
+    // — the self-match guard compares `{origin, content}`.
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'single-template-reyield', 'Parent.gts');
+    const parentSource = findTemplateSource({ declFile: origin, ts });
+    expect(parentSource).not.toBeNull();
+    const r = resolveYieldHashBinding({
+      parentSource: parentSource!,
+      hashKey: 'Thing',
+      parentArgs: new Map(),
+      ts,
+    });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('section');
+  });
 });

From 05c0d76847549e2a18787f82bf8c0b9078332fed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 22 May 2026 00:39:11 +0200
Subject: [PATCH 7/9] re-yield: align binder-tag predicate with wrapper
 recursion

findBlockParamBinder gated on /^[A-Z][A-Za-z0-9]*$/, stricter than the
wrapper-recursion gate in resolveElement (/^[A-Z]/ + no '.' + no ':'),
so namespaced (Foo::Bar) and underscore binder tags were missed and the
re-yield chain silently fell back to TRANSPARENT. Extract the shared
isResolvableWrapperTag predicate and use it in both places so they can't
drift apart.
---
 lib/resolver/walk.ts                          | 18 ++++++++++++----
 .../reyield-underscore-binder.gts             | 18 ++++++++++++++++
 test/resolver/walk.test.ts                    | 21 +++++++++++++++++++
 3 files changed, 53 insertions(+), 4 deletions(-)
 create mode 100644 test/glint-fixtures/reyield-underscore-binder.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index 0b2fbf7..beb1e21 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -218,7 +218,7 @@ function resolveElement(
   }
 
   // PascalCase wrapper → recurse.
-  if (/^[A-Z]/.test(node.tag) && !node.tag.includes('.') && !node.tag.startsWith(':')) {
+  if (isResolvableWrapperTag(node.tag)) {
     const resolution = resolvePascalRecursion(node, source, options);
     if (resolution.kind !== 'transparent') return resolution;
     // Pure-yield wrappers (template body is `{{yield (...)}}` only,
@@ -1022,8 +1022,8 @@ function resolveBlockParamReyield(
 // we track the element-ancestor stack while walking and, on reaching the
 // matching re-yield entry, pick the closest ancestor that binds the param.
 //
-// Restricted to resolvable PascalCase tags (`/^[A-Z][A-Za-z0-9]*$/`):
-// dotted (`F.Foo`) and colon (`:slot`) tags can't be resolved via
+// Restricted to resolvable wrapper tags (`isResolvableWrapperTag`):
+// dotted (`F.Foo`) and named-block (`:body`) tags can't be resolved via
 // import/by-name, so matching them would only yield a useless TRANSPARENT.
 function findBlockParamBinder(
   ast: AST.Template,
@@ -1036,7 +1036,7 @@ function findBlockParamBinder(
   function nearestBinder(): AST.ElementNode | null {
     for (let i = stack.length - 1; i >= 0; i--) {
       const el = stack[i]!;
-      if (/^[A-Z][A-Za-z0-9]*$/.test(el.tag) && el.blockParams.includes(paramName)) {
+      if (isResolvableWrapperTag(el.tag) && el.blockParams.includes(paramName)) {
         return el;
       }
     }
@@ -1507,3 +1507,13 @@ const NATIVE_TAGS = new Set<string>([...htmlTags, ...svgTags, ...mathmlTagNames]
 function isNativeTagName(tag: string): boolean {
   return NATIVE_TAGS.has(tag);
 }
+
+// A tag we attempt to resolve as a component wrapper: PascalCase, not
+// dotted (`F.Item` is a yield-binding/curried path), not a named-block
+// slot (`:body`). Deliberately broader than `/^[A-Z][A-Za-z0-9]*$/` so it
+// also covers namespaced (`Foo::Bar`) and underscore identifiers — the
+// same set the wrapper-recursion and block-param-binder lookups treat as
+// resolvable, kept in one place so the two can't drift apart.
+function isResolvableWrapperTag(tag: string): boolean {
+  return /^[A-Z]/.test(tag) && !tag.includes('.') && !tag.startsWith(':');
+}
diff --git a/test/glint-fixtures/reyield-underscore-binder.gts b/test/glint-fixtures/reyield-underscore-binder.gts
new file mode 100644
index 0000000..6e588c1
--- /dev/null
+++ b/test/glint-fixtures/reyield-underscore-binder.gts
@@ -0,0 +1,18 @@
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+interface LeafSig {
+  Element: HTMLElement;
+  Blocks: { default: [] };
+}
+const Aside: TOC<LeafSig> = <template><aside ...attributes>{{yield}}</aside></template>;
+
+// Binder tag has an underscore — a resolvable wrapper the rest of the
+// resolver accepts (`/^[A-Z]/`, not dotted, not `:slot`), but which the
+// old `/^[A-Z][A-Za-z0-9]*$/` binder regex rejected, dropping the re-yield
+// chain. Its `Item` re-yields `<Aside>` (→ `<aside>`).
+interface BinderSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Item: unknown }] };
+}
+const My_Binder: TOC<BinderSig> = <template>{{yield (hash Item=Aside)}}</template>;
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 73aaf1a..6c59b40 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -321,4 +321,25 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('section');
   });
+
+  test('binder tag with an underscore resolves (matches the wrapper predicate)', async () => {
+    // `<My_Binder>` is a resolvable wrapper everywhere else in the
+    // resolver, but the old `/^[A-Z][A-Za-z0-9]*$/` binder regex rejected
+    // the underscore, dropping the re-yield chain to TRANSPARENT. With the
+    // shared `isResolvableWrapperTag` predicate it resolves → `<aside>`.
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'reyield-underscore-binder.gts');
+    const r = resolveYieldHashBinding({
+      parentSource: {
+        content: `<My_Binder as |F|>{{yield (hash Thing=F.Item)}}</My_Binder>`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Thing',
+      parentArgs: new Map(),
+      ts,
+    });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('aside');
+  });
 });

From d48e415362f00307c96ec52295d560d7a30c59ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 22 May 2026 00:50:56 +0200
Subject: [PATCH 8/9] re-yield: bind to the matched entry's in-scope binder;
 follow re-yields at source level

findYieldHashEntry now captures the matched entry's element-ancestor
stack, and re-yield resolution picks the binder from THAT stack via
nearestBinderFor. This ties the binder to the exact entry resolved, so a
re-yield value (F.Item) reused under several binders no longer mis-binds
to the first occurrence (replaces the global findBlockParamBinder walk).

resolveYieldHashBindingSource gains a re-yield branch mirroring
resolveBlockParamReyield via the shared resolveBinderSource helper, so
deeper dotted chains off a re-yielded component resolve at the source
level too (leaf resolver and source chainer stay in sync).
---
 lib/resolver/walk.ts                          | 330 ++++++++----------
 .../reyield-dup-value-binders.gts             |  21 ++
 test/glint-fixtures/reyield-source-chain.gts  |  18 +
 test/resolver/walk.test.ts                    |  45 +++
 4 files changed, 234 insertions(+), 180 deletions(-)
 create mode 100644 test/glint-fixtures/reyield-dup-value-binders.gts
 create mode 100644 test/glint-fixtures/reyield-source-chain.gts

diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index beb1e21..e89509f 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -893,10 +893,10 @@ export function resolveYieldHashBinding(opts: YieldHashBindingOptions): Resoluti
     return TRANSPARENT;
   }
 
-  const binding = findYieldHashEntry(ast, hashKey);
-  if (!binding) return TRANSPARENT;
+  const entry = findYieldHashEntry(ast, hashKey);
+  if (!entry) return TRANSPARENT;
 
-  return resolveBinding(binding, parentSource, ast, {
+  return resolveBinding(entry.value, parentSource, entry.ancestors, {
     consumerArgs: parentArgs,
     ts: ts ?? null,
     visited,
@@ -905,38 +905,50 @@ export function resolveYieldHashBinding(opts: YieldHashBindingOptions): Resoluti
 }
 
 // Resolve a re-yielded block-param hash entry: `{{yield (hash
-// Legend=F.Legend)}}` where `F` is a block param from `<Binder as |F|>`
-// in this same template. The yielded sub-component is whatever `Binder`
-// itself yields under `Legend`, so resolve `Binder`'s source and recurse
-// into its yield-hash. Mirrors HDS's `HdsFormCheckboxGroup` re-yielding
-// `HdsFormFieldset`'s `F.Legend` — without this `<G.Legend>` fell back to
-// the binder's `<fieldset>` Element type and FP-fired `wcag/h71`.
-// Returns `null` (rather than TRANSPARENT) when `paramName` is not a
-// block param introduced in this template — i.e. the `VarHead`+tail was
-// general property access, not a re-yield. The caller then falls back to
-// the prior `resolveByName(head)` behavior. A binder that IS found but
-// fails to resolve still returns TRANSPARENT (the FP-safe answer).
+// Legend=F.Legend)}}` where `F` is the block param of the enclosing
+// `<Binder as |F|>` (`binderNode`). The yielded sub-component is whatever
+// `Binder` itself yields under `Legend`, so resolve `Binder`'s source and
+// recurse into its yield-hash. Mirrors HDS's `HdsFormCheckboxGroup`
+// re-yielding `HdsFormFieldset`'s `F.Legend` — without this `<G.Legend>`
+// fell back to the binder's `<fieldset>` Element type and FP-fired
+// `wcag/h71`. `binderNode` is the EXACT in-scope binder for the resolved
+// entry (from its ancestor stack), so a re-yield value reused under
+// several binders resolves against the right one.
 function resolveBlockParamReyield(
-  paramName: string,
+  binderNode: AST.ElementNode,
   hashKey: string,
   parentSource: TemplateSource,
-  parentAst: AST.Template,
   options: ResolveOptions,
-): Resolution | null {
+): Resolution {
   const depth = options.depth ?? 0;
   if (depth >= MAX_DEPTH) return TRANSPARENT;
-  const binderNode = findBlockParamBinder(parentAst, paramName, hashKey);
-  if (!binderNode) return null;
-  const binderTag = binderNode.tag;
-
-  // The binder is invoked WITHIN this template (`<Binder @x="y" as |F|>`),
-  // so any `@arg`-driven yield-hash entry inside Binder must resolve
-  // against the args passed HERE — not the outer component's consumer
-  // args. Collect:
-  //   - literal `@arg="lit"`,
-  //   - `@arg={{@caller}}` passthrough (look up in this component's args),
-  //   - `@arg={{this.prop}}` class-derived literal (walk this component's
-  //     getter, mirroring `resolvePascalRecursionWith`).
+
+  const binderArgs = collectBinderArgs(binderNode, parentSource, options);
+  const binderSource = resolveBinderSource(binderNode.tag, parentSource, options.ts ?? null);
+  if (!binderSource) return TRANSPARENT;
+
+  return resolveYieldHashBinding({
+    parentSource: binderSource,
+    hashKey,
+    parentArgs: binderArgs,
+    ts: options.ts ?? null,
+    visited: options.visited,
+    depth: depth + 1,
+  });
+}
+
+// The binder is invoked WITHIN this template (`<Binder @x="y" as |F|>`),
+// so any `@arg`-driven yield-hash entry inside Binder must resolve against
+// the args passed HERE — not the outer component's consumer args. Collect:
+//   - literal `@arg="lit"`,
+//   - `@arg={{@caller}}` passthrough (look up in this component's args),
+//   - `@arg={{this.prop}}` class-derived literal (walk this component's
+//     getter, mirroring `resolvePascalRecursionWith`).
+function collectBinderArgs(
+  binderNode: AST.ElementNode,
+  parentSource: TemplateSource,
+  options: ResolveOptions,
+): Map<string, string> {
   const binderArgs = new Map<string, string>();
   for (const attr of binderNode.attributes) {
     if (!attr.name.startsWith('@')) continue;
@@ -961,135 +973,7 @@ function resolveBlockParamReyield(
       }
     }
   }
-
-  // Resolve the binder's source, mirroring `resolvePascalRecursion`'s
-  // lookup order so re-yield chains resolve under every consumer style:
-  //   1. `import Binder from '...'` in this template's origin.
-  //   2. Same-file declaration (`const Binder = <template>…` in this .gts).
-  //   3. v1-addon by-name resolution (`.hbs` consumers — no imports).
-  //   4. Sibling-file probe (same dir as origin) as a last resort.
-  const importedFile = resolveImport(parentSource.origin, binderTag, options.ts ?? null);
-  let binderSource: TemplateSource | null = importedFile
-    ? findTemplateSource({ declFile: importedFile, ts: options.ts ?? null })
-    : null;
-  if (!binderSource) {
-    const sameFile = findTemplateSource({
-      declFile: parentSource.origin,
-      componentName: binderTag,
-      ts: options.ts ?? null,
-    });
-    // `findTemplateSource` returns a file's sole `<template>` regardless
-    // of `componentName` for single-template files (every `.hbs`, many
-    // `.gts`/`.gjs`). That would be the PARENT itself — recursing on it
-    // self-matches until MAX_DEPTH → TRANSPARENT, AND short-circuits the
-    // by-name / sibling probes below. Accept the same-file decl only when
-    // it selected a DIFFERENT `<template>` block (the multi-template case
-    // where the binder really is a sibling declaration in this file).
-    if (sameFile && !(sameFile.origin === parentSource.origin && sameFile.content === parentSource.content)) {
-      binderSource = sameFile;
-    }
-  }
-  if (!binderSource) {
-    binderSource = findTemplateSource({
-      consumerFile: parentSource.origin,
-      componentName: binderTag,
-      ts: options.ts ?? null,
-    });
-  }
-  if (!binderSource) {
-    binderSource = trySiblingProbe(parentSource.origin, binderTag);
-  }
-  if (!binderSource) return TRANSPARENT;
-
-  return resolveYieldHashBinding({
-    parentSource: binderSource,
-    hashKey,
-    parentArgs: binderArgs,
-    ts: options.ts ?? null,
-    visited: options.visited,
-    depth: depth + 1,
-  });
-}
-
-// Find the in-scope binder for a re-yielded reference `paramName.hashKey`:
-// the NEAREST enclosing `<Tag as |…paramName…|>` ancestor of the
-// `{{yield (hash <key>=paramName.hashKey)}}` statement that produces it.
-//
-// Scoping to the actual reference — rather than returning the first
-// element in the template whose block params happen to include
-// `paramName` — keeps resolution correct when a short param name (like
-// `F`) is reused across sibling blocks or shadowed by a nested binder:
-// we track the element-ancestor stack while walking and, on reaching the
-// matching re-yield entry, pick the closest ancestor that binds the param.
-//
-// Restricted to resolvable wrapper tags (`isResolvableWrapperTag`):
-// dotted (`F.Foo`) and named-block (`:body`) tags can't be resolved via
-// import/by-name, so matching them would only yield a useless TRANSPARENT.
-function findBlockParamBinder(
-  ast: AST.Template,
-  paramName: string,
-  hashKey: string,
-): AST.ElementNode | null {
-  const stack: AST.ElementNode[] = [];
-
-  // Nearest enclosing element on the stack that binds `paramName`.
-  function nearestBinder(): AST.ElementNode | null {
-    for (let i = stack.length - 1; i >= 0; i--) {
-      const el = stack[i]!;
-      if (isResolvableWrapperTag(el.tag) && el.blockParams.includes(paramName)) {
-        return el;
-      }
-    }
-    return null;
-  }
-
-  // Is `node` a `{{yield (hash <anyKey>=paramName.hashKey)}}` re-yield
-  // entry? We match on the entry's VALUE (`paramName.hashKey` — the
-  // re-yielded reference) rather than the outer hash key it's bound
-  // under, which is arbitrary and unrelated to which binder is in scope.
-  function isReyieldEntry(node: AST.Node): boolean {
-    if (node.type !== 'MustacheStatement' && node.type !== 'SubExpression') return false;
-    const mu = node as AST.MustacheStatement | AST.SubExpression;
-    if (mu.path.type !== 'PathExpression' || mu.path.original !== 'yield') return false;
-    for (const param of mu.params) {
-      if (param.type !== 'SubExpression') continue;
-      if (param.path.type !== 'PathExpression' || param.path.original !== 'hash') continue;
-      for (const pair of param.hash.pairs) {
-        const v = pair.value;
-        if (
-          v.type === 'PathExpression'
-          && v.head?.type === 'VarHead'
-          && v.head.name === paramName
-          && v.tail[0] === hashKey
-        ) return true;
-      }
-    }
-    return false;
-  }
-
-  let result: AST.ElementNode | null = null;
-  function visit(node: AST.Node): void {
-    if (result) return;
-    if (isReyieldEntry(node)) {
-      const binder = nearestBinder();
-      if (binder) {
-        result = binder;
-        return;
-      }
-    }
-    if (node.type === 'ElementNode') {
-      stack.push(node);
-      for (const child of node.children) visit(child);
-      stack.pop();
-    } else if (node.type === 'BlockStatement') {
-      for (const child of node.program.body) visit(child);
-      if (node.inverse) for (const child of node.inverse.body) visit(child);
-    } else if (node.type === 'Template') {
-      for (const child of node.body) visit(child);
-    }
-  }
-  visit(ast);
-  return result;
+  return binderArgs;
 }
 
 // Like `resolveYieldHashBinding` but returns the underlying
@@ -1121,12 +1005,12 @@ export function resolveYieldHashBindingSource(
     return null;
   }
 
-  const binding = findYieldHashEntry(ast, hashKey);
-  if (!binding) return null;
+  const entry = findYieldHashEntry(ast, hashKey);
+  if (!entry) return null;
 
   // Unwrap `(component Inner @arg="lit" …)` to extract the inner
   // identifier + curried args.
-  let target: AST.Expression = binding;
+  let target: AST.Expression = entry.value;
   const curriedArgs = new Map<string, string>();
   if (
     target.type === 'SubExpression'
@@ -1142,9 +1026,34 @@ export function resolveYieldHashBindingSource(
     target = target.params[0];
   }
 
-  // Now `target` should be a bare identifier (VarHead PathExpression).
   if (target.type !== 'PathExpression') return null;
   if (target.head?.type !== 'VarHead') return null;
+
+  // Re-yield: `Header=F.Header` where `F` is the block param of an
+  // enclosing `<Binder as |F|>`. Mirror `resolveBlockParamReyield` at the
+  // source level — resolve the binder's source and follow ITS yield-hash
+  // for the inner key — so deeper dotted chains off a re-yielded component
+  // can be followed (the leaf resolver and the source chainer stay in
+  // sync). Falls back to the bare-identifier path when `F` isn't a binder.
+  if (target.tail.length > 0) {
+    const d = depth ?? 0;
+    const binderNode = d < MAX_DEPTH ? nearestBinderFor(entry.ancestors, target.head.name) : null;
+    if (binderNode) {
+      const binderSource = resolveBinderSource(binderNode.tag, parentSource, ts ?? null);
+      if (!binderSource) return null;
+      const nested = resolveYieldHashBindingSource({
+        parentSource: binderSource,
+        hashKey: target.tail[0]!,
+        ts: ts ?? null,
+        visited,
+        depth: d + 1,
+      });
+      if (!nested) return null;
+      return { source: nested.source, curriedArgs: new Map([...curriedArgs, ...nested.curriedArgs]) };
+    }
+    return null;
+  }
+
   const name = target.head.name;
 
   // Reuse `resolveImport` + `findTemplateSource` directly so we get
@@ -1162,19 +1071,29 @@ export function resolveYieldHashBindingSource(
     });
   }
   if (!source) return null;
-  // Track visited / depth in case the caller chains multiple hops.
+  // Track visited in case the caller chains multiple hops.
   void visited;
-  void depth;
   return { source, curriedArgs };
 }
 
-// Walk the parent template for `{{yield (hash <hashKey>=<expr>)}}` and
-// return <expr>, or null when not found.
+interface YieldHashEntry {
+  /** The `{{yield (hash <hashKey>=<value>)}}` entry's value expression. */
+  value: AST.Expression;
+  /** ElementNode ancestors of the matched entry, outermost first. Lets a
+   *  re-yield value (`F.Legend`) resolve its in-scope binder (`<Binder as
+   *  |F|>`) to the one actually wrapping THIS entry — not merely the first
+   *  binder in the template that binds the same param name. */
+  ancestors: AST.ElementNode[];
+}
+
+// Walk the parent template for the FIRST `{{yield (hash <hashKey>=<expr>)}}`
+// and return its value + enclosing element ancestors, or null when absent.
 function findYieldHashEntry(
   ast: AST.Template,
   hashKey: string,
-): AST.Expression | null {
-  let result: AST.Expression | null = null;
+): YieldHashEntry | null {
+  let result: YieldHashEntry | null = null;
+  const stack: AST.ElementNode[] = [];
   function visit(node: AST.Node): void {
     if (result) return;
     if (node.type === 'MustacheStatement' || node.type === 'SubExpression') {
@@ -1186,7 +1105,7 @@ function findYieldHashEntry(
           if (param.path.original !== 'hash') continue;
           for (const pair of param.hash.pairs) {
             if (pair.key === hashKey) {
-              result = pair.value;
+              result = { value: pair.value, ancestors: [...stack] };
               return;
             }
           }
@@ -1194,7 +1113,9 @@ function findYieldHashEntry(
       }
     }
     if (node.type === 'ElementNode') {
+      stack.push(node);
       for (const child of node.children) visit(child);
+      stack.pop();
     } else if (node.type === 'BlockStatement') {
       for (const child of node.program.body) visit(child);
       if (node.inverse) for (const child of node.inverse.body) visit(child);
@@ -1206,6 +1127,53 @@ function findYieldHashEntry(
   return result;
 }
 
+// Nearest enclosing binder (`<Tag as |…paramName…|>`) among an entry's
+// element ancestors — the in-scope binder for a re-yielded `paramName.key`
+// reference. Restricted to resolvable wrapper tags (`isResolvableWrapperTag`):
+// dotted (`F.Foo`) / named-block (`:body`) binders can't be name-resolved.
+function nearestBinderFor(
+  ancestors: ReadonlyArray<AST.ElementNode>,
+  paramName: string,
+): AST.ElementNode | null {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const el = ancestors[i]!;
+    if (isResolvableWrapperTag(el.tag) && el.blockParams.includes(paramName)) return el;
+  }
+  return null;
+}
+
+// Resolve the TemplateSource of a binder element (`<Binder …>`) invoked
+// within `parentSource`'s template, mirroring resolvePascalRecursion's
+// lookup order. Shared by both the leaf (resolveBlockParamReyield) and the
+// source (resolveYieldHashBindingSource) re-yield paths so they stay in
+// sync. The same-file lookup is gated against the degenerate self-match:
+// single-template files (every `.hbs`, many `.gts/.gjs`) return their sole
+// `<template>` regardless of the requested name, which would be the parent
+// itself — accept it only when it picked a DIFFERENT block.
+function resolveBinderSource(
+  binderTag: string,
+  parentSource: TemplateSource,
+  ts: typeof TS | null,
+): TemplateSource | null {
+  const importedFile = resolveImport(parentSource.origin, binderTag, ts);
+  let binderSource: TemplateSource | null = importedFile
+    ? findTemplateSource({ declFile: importedFile, ts })
+    : null;
+  if (!binderSource) {
+    const sameFile = findTemplateSource({ declFile: parentSource.origin, componentName: binderTag, ts });
+    if (sameFile && !(sameFile.origin === parentSource.origin && sameFile.content === parentSource.content)) {
+      binderSource = sameFile;
+    }
+  }
+  if (!binderSource) {
+    binderSource = findTemplateSource({ consumerFile: parentSource.origin, componentName: binderTag, ts });
+  }
+  if (!binderSource) {
+    binderSource = trySiblingProbe(parentSource.origin, binderTag);
+  }
+  return binderSource;
+}
+
 // Resolve a binding expression (the value of a hash entry) to a
 // Resolution. Three forms:
 //   - PathExpression with VarHead (`WrappedStep`): in-scope identifier;
@@ -1217,7 +1185,7 @@ function findYieldHashEntry(
 function resolveBinding(
   expr: AST.Expression,
   parentSource: TemplateSource,
-  parentAst: AST.Template,
+  ancestors: ReadonlyArray<AST.ElementNode>,
   options: ResolveOptions,
 ): Resolution {
   // `Title=(component HdsFormHeaderTitle size="300")` — the hash
@@ -1240,7 +1208,7 @@ function resolveBinding(
         curriedArgs.set(pair.key, pair.value.value);
       }
     }
-    return resolveBinding(componentRef, parentSource, parentAst, {
+    return resolveBinding(componentRef, parentSource, ancestors, {
       ...options,
       consumerArgs: curriedArgs,
     });
@@ -1250,16 +1218,18 @@ function resolveBinding(
   if (!expr.head) return TRANSPARENT;
 
   if (expr.head.type === 'VarHead') {
-    // `F.Legend` — when `F` is a block param introduced by `<Binder as
-    // |F|>` in THIS template, the yielded sub-component is whatever Binder
-    // re-yields under `Legend`. But `VarHead`+tail is also the general
-    // shape for property access on any in-scope value; when `F` is not a
-    // block param, `resolveBlockParamReyield` returns null and we fall
-    // back to resolving the head name directly (the prior behavior).
-    // (A bare `Foo` with no tail is a local import / in-scope component.)
+    // `F.Legend` — when `F` is the block param of an enclosing `<Binder as
+    // |F|>`, the yielded sub-component is whatever Binder re-yields under
+    // `Legend`. But `VarHead`+tail is also the general shape for property
+    // access on any in-scope value; when `F` is not a binder block param
+    // (no matching ancestor), fall back to resolving the head name
+    // directly (the prior behavior). A bare `Foo` with no tail is a local
+    // import / in-scope component.
     if (expr.tail.length > 0) {
-      const reyield = resolveBlockParamReyield(expr.head.name, expr.tail[0]!, parentSource, parentAst, options);
-      if (reyield !== null) return reyield;
+      const binderNode = nearestBinderFor(ancestors, expr.head.name);
+      if (binderNode) {
+        return resolveBlockParamReyield(binderNode, expr.tail[0]!, parentSource, options);
+      }
     }
     return resolveByName(expr.head.name, parentSource, options);
   }
diff --git a/test/glint-fixtures/reyield-dup-value-binders.gts b/test/glint-fixtures/reyield-dup-value-binders.gts
new file mode 100644
index 0000000..9bf79b7
--- /dev/null
+++ b/test/glint-fixtures/reyield-dup-value-binders.gts
@@ -0,0 +1,21 @@
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+interface LeafSig {
+  Element: HTMLElement;
+  Blocks: { default: [] };
+}
+const SectionLeaf: TOC<LeafSig> = <template><section ...attributes>{{yield}}</section></template>;
+const ArticleLeaf: TOC<LeafSig> = <template><article ...attributes>{{yield}}</article></template>;
+
+// Two binders that BOTH bind `F` and BOTH re-yield the same value
+// `F.Item` — but under different outer keys. Resolving the `Thing` key
+// must pick BinderB's binder (→ `<article>`), the one wrapping the
+// `Thing=F.Item` entry, not the first `F.Item` occurrence (BinderA →
+// `<section>`).
+interface BinderSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Item: unknown }] };
+}
+const BinderA: TOC<BinderSig> = <template>{{yield (hash Item=SectionLeaf)}}</template>;
+const BinderB: TOC<BinderSig> = <template>{{yield (hash Item=ArticleLeaf)}}</template>;
diff --git a/test/glint-fixtures/reyield-source-chain.gts b/test/glint-fixtures/reyield-source-chain.gts
new file mode 100644
index 0000000..f992de7
--- /dev/null
+++ b/test/glint-fixtures/reyield-source-chain.gts
@@ -0,0 +1,18 @@
+import { hash } from '@ember/helper';
+import type { TOC } from '@ember/component/template-only';
+
+interface LeafSig {
+  Element: HTMLElement;
+  Blocks: { default: [] };
+}
+const Leaf: TOC<LeafSig> = <template><article ...attributes>{{yield}}</article></template>;
+
+// Binder yields `Inner=Leaf`. A parent that re-yields `Section=F.Inner`
+// (F bound by `<Binder as |F|>`) must be followable at the SOURCE level
+// (resolveYieldHashBindingSource) down to Leaf — not just at the leaf
+// resolver — so deeper dotted chains off the re-yielded component work.
+interface BinderSig {
+  Element: HTMLElement;
+  Blocks: { default: [{ Inner: unknown }] };
+}
+const Binder: TOC<BinderSig> = <template>{{yield (hash Inner=Leaf)}}</template>;
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 6c59b40..6fae764 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -342,4 +342,49 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('aside');
   });
+
+  test('same re-yield value under two binders resolves against the matched entry', async () => {
+    // `F.Item` appears under BinderA (`Other=F.Item`) and BinderB
+    // (`Thing=F.Item`). Resolving `Thing` must bind to BinderB's binder
+    // (→ `<article>`), tied to the entry `findYieldHashEntry` returned —
+    // not the first `F.Item` occurrence (BinderA → `<section>`).
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'reyield-dup-value-binders.gts');
+    const r = resolveYieldHashBinding({
+      parentSource: {
+        content:
+          `<BinderA as |F|>{{yield (hash Other=F.Item)}}</BinderA>` +
+          `<BinderB as |F|>{{yield (hash Thing=F.Item)}}</BinderB>`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Thing',
+      parentArgs: new Map(),
+      ts,
+    });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('article');
+  });
+
+  test('resolveYieldHashBindingSource follows a re-yielded binding (source-level parity)', async () => {
+    // `Section=F.Inner` is a re-yield; the source chainer must resolve the
+    // binder (`<Binder as |F|>`) and follow its `Inner` to Leaf, instead of
+    // treating the name as `F` and returning null. Verifies leaf resolver
+    // and source chainer stay in sync for deeper dotted chains.
+    const { resolveYieldHashBindingSource, resolveTemplate } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'reyield-source-chain.gts');
+    const res = resolveYieldHashBindingSource({
+      parentSource: {
+        content: `<Binder as |F|>{{yield (hash Section=F.Inner)}}</Binder>`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Section',
+      ts,
+    });
+    expect(res).not.toBeNull();
+    const r = resolveTemplate(res!.source, { ts });
+    expect(r.kind).toBe('tag');
+    expect((r as { tag: string }).tag).toBe('article');
+  });
 });

From a00c2601e384f122b7def9f7acf9e0437e42b7fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Fri, 22 May 2026 00:59:31 +0200
Subject: [PATCH 9/9] re-yield: pin binder @arg tail forms; share wrapper
 predicate with build-maps; fall back on non-binder dotted source

- collectBinderArgs: only pin simple @foo (no tail) and this.foo (single
  tail) forms; @foo.bar / this.a.b are property access and were being
  mistaken for the bare arg, setting wrong binderArgs.
- resolveYieldHashBindingSource: when a dotted target's head isn't a
  binder, fall through to the bare-identifier path (matches the leaf
  resolveByName(head) fallback and pre-refactor behavior) instead of
  returning null.
- Export isResolvableWrapperTag and use it in buildResolutionMaps so the
  no-Glint path accepts the same wrapper tags (underscore/namespaced) as
  walk.ts, keeping resolver entry points consistent.
- Update a stale test comment to match the ancestor-based binder lookup.
---
 lib/resolver/build-maps.ts |  7 +++++--
 lib/resolver/walk.ts       | 24 ++++++++++++++++--------
 test/resolver/walk.test.ts | 24 ++++++++++++++++++++++--
 3 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/lib/resolver/build-maps.ts b/lib/resolver/build-maps.ts
index 8081dcd..47bd1cd 100644
--- a/lib/resolver/build-maps.ts
+++ b/lib/resolver/build-maps.ts
@@ -13,7 +13,7 @@ import { BUILTIN_COMPONENTS } from '../builtin-components.js';
 import type { ComponentAttrs } from '../builtin-components.js';
 import { isComponentTag } from '../../blank.js';
 import { findTemplateSource } from './template-source.js';
-import { chooseSubstitution, resolveTemplate } from './walk.js';
+import { chooseSubstitution, resolveTemplate, isResolvableWrapperTag } from './walk.js';
 
 const BUILTIN_COMPONENT_NAMES: ReadonlySet<string> = new Set(BUILTIN_COMPONENTS.keys());
 
@@ -64,7 +64,10 @@ export function buildResolutionMaps(
   traverse(ast, {
     ElementNode(node) {
       const tag = node.tag;
-      if (!/^[A-Z][A-Za-z0-9]*$/.test(tag)) return;
+      // Same wrapper-eligibility predicate as walk.ts's resolution paths
+      // (covers underscore/namespaced tags), so no-Glint resolution stays
+      // consistent with the Glint path.
+      if (!isResolvableWrapperTag(tag)) return;
       if (BUILTIN_COMPONENT_NAMES.has(tag)) return;
       if (!node.loc.start) return;
       const source = findTemplateSource({
diff --git a/lib/resolver/walk.ts b/lib/resolver/walk.ts
index e89509f..9397743 100644
--- a/lib/resolver/walk.ts
+++ b/lib/resolver/walk.ts
@@ -960,13 +960,18 @@ function collectBinderArgs(
       && attr.value.path.type === 'PathExpression'
     ) {
       const expr = attr.value.path;
-      if (expr.head?.type === 'AtHead') {
+      // Only the simple forms are statically pinnable: `@foo` (no tail)
+      // and `this.foo` (single tail segment). `@foo.bar` is property
+      // access on an arg, and `this.a.b` walks past a single getter —
+      // treating either as the bare `@foo` / `this.a` would set a wrong
+      // binderArg, so skip them.
+      if (expr.head?.type === 'AtHead' && expr.tail.length === 0) {
         const caller = expr.head.name.replace(/^@/, '');
         const v = options.consumerArgs?.get(caller);
         if (v !== undefined) binderArgs.set(argName, v);
-      } else if (expr.head?.type === 'ThisHead') {
-        const propName = expr.tail[0];
-        if (propName && options.ts) {
+      } else if (expr.head?.type === 'ThisHead' && expr.tail.length === 1) {
+        const propName = expr.tail[0]!;
+        if (options.ts) {
           const v = resolveThisProp(parentSource, propName, options);
           if (v !== null) binderArgs.set(argName, v);
         }
@@ -1034,7 +1039,9 @@ export function resolveYieldHashBindingSource(
   // source level — resolve the binder's source and follow ITS yield-hash
   // for the inner key — so deeper dotted chains off a re-yielded component
   // can be followed (the leaf resolver and the source chainer stay in
-  // sync). Falls back to the bare-identifier path when `F` isn't a binder.
+  // sync). When `F` is NOT a binder, fall through to the bare-identifier
+  // path below (resolves the head, ignoring the tail — matching the leaf
+  // resolver's `resolveByName(head)` fallback).
   if (target.tail.length > 0) {
     const d = depth ?? 0;
     const binderNode = d < MAX_DEPTH ? nearestBinderFor(entry.ancestors, target.head.name) : null;
@@ -1051,7 +1058,6 @@ export function resolveYieldHashBindingSource(
       if (!nested) return null;
       return { source: nested.source, curriedArgs: new Map([...curriedArgs, ...nested.curriedArgs]) };
     }
-    return null;
   }
 
   const name = target.head.name;
@@ -1483,7 +1489,9 @@ function isNativeTagName(tag: string): boolean {
 // slot (`:body`). Deliberately broader than `/^[A-Z][A-Za-z0-9]*$/` so it
 // also covers namespaced (`Foo::Bar`) and underscore identifiers — the
 // same set the wrapper-recursion and block-param-binder lookups treat as
-// resolvable, kept in one place so the two can't drift apart.
-function isResolvableWrapperTag(tag: string): boolean {
+// resolvable, kept in one place so the resolver entry points (this file's
+// wrapper recursion + re-yield binder lookup, and the no-Glint
+// `buildResolutionMaps`) can't drift apart on wrapper eligibility.
+export function isResolvableWrapperTag(tag: string): boolean {
   return /^[A-Z]/.test(tag) && !tag.includes('.') && !tag.startsWith(':');
 }
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 6fae764..8141a6a 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -239,8 +239,8 @@ describe('resolveYieldHashBinding', () => {
   test('VarHead+tail whose head is NOT a block param falls back to resolveByName', async () => {
     // `NavList.Item` is property access on an in-scope const, not a
     // block-param re-yield (`NavList` is never bound via `as |NavList|`).
-    // `resolveBlockParamReyield` returns null for the missing binder, so
-    // the caller falls back to resolving the head (`NavList`) by name —
+    // No enclosing binder matches, so the re-yield path is skipped and
+    // resolution falls back to resolving the head (`NavList`) by name —
     // restoring the pre-re-yield behavior instead of bailing TRANSPARENT.
     const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
     const origin = path.join(FIXTURES, 'dotted-nonblockparam-binding.gts');
@@ -387,4 +387,24 @@ describe('resolveYieldHashBinding', () => {
     expect(r.kind).toBe('tag');
     expect((r as { tag: string }).tag).toBe('article');
   });
+
+  test('binder @arg with a tail segment (@cfg.tag) is not mistaken for an @cfg passthrough', async () => {
+    // The binder's `Item=@elementTag`. Passing `@elementTag={{@cfg.tag}}`
+    // is property access on `@cfg`, NOT the bare `@cfg` arg — so it must
+    // not bind `elementTag` to `@cfg`'s value ('section'). With the arg
+    // left unresolved, the binder's `Item` stays TRANSPARENT.
+    const { resolveYieldHashBinding } = await import('../../lib/resolver/walk.js');
+    const origin = path.join(FIXTURES, 'reyield-binder-thisprop-arg.gts');
+    const r = resolveYieldHashBinding({
+      parentSource: {
+        content: `<Binder @elementTag={{@cfg.tag}} as |F|>{{yield (hash Thing=F.Item)}}</Binder>`,
+        origin,
+        kind: 'gts',
+      },
+      hashKey: 'Thing',
+      parentArgs: new Map([['cfg', 'section']]),
+      ts,
+    });
+    expect(r.kind).toBe('transparent');
+  });
 });