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 a613a7b..9397743 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,
@@ -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, {
+  return resolveBinding(entry.value, parentSource, entry.ancestors, {
     consumerArgs: parentArgs,
     ts: ts ?? null,
     visited,
@@ -904,6 +904,83 @@ export function resolveYieldHashBinding(opts: YieldHashBindingOptions): Resoluti
   });
 }
 
+// Resolve a re-yielded block-param hash entry: `{{yield (hash
+// 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(
+  binderNode: AST.ElementNode,
+  hashKey: string,
+  parentSource: TemplateSource,
+  options: ResolveOptions,
+): Resolution {
+  const depth = options.depth ?? 0;
+  if (depth >= MAX_DEPTH) return TRANSPARENT;
+
+  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;
+    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'
+    ) {
+      const expr = attr.value.path;
+      // 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' && 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);
+        }
+      }
+    }
+  }
+  return binderArgs;
+}
+
 // Like `resolveYieldHashBinding` but returns the underlying
 // `TemplateSource` (plus any curried `@arg` additions from a
 // `(component Inner …)` wrapper) instead of the leaf `Resolution`.
@@ -933,12 +1010,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'
@@ -954,9 +1031,35 @@ 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). 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;
+    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]) };
+    }
+  }
+
   const name = target.head.name;
 
   // Reuse `resolveImport` + `findTemplateSource` directly so we get
@@ -974,19 +1077,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') {
@@ -998,7 +1111,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;
             }
           }
@@ -1006,7 +1119,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);
@@ -1018,6 +1133,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;
@@ -1029,6 +1191,7 @@ function findYieldHashEntry(
 function resolveBinding(
   expr: AST.Expression,
   parentSource: TemplateSource,
+  ancestors: ReadonlyArray<AST.ElementNode>,
   options: ResolveOptions,
 ): Resolution {
   // `Title=(component HdsFormHeaderTitle size="300")` — the hash
@@ -1051,7 +1214,7 @@ function resolveBinding(
         curriedArgs.set(pair.key, pair.value.value);
       }
     }
-    return resolveBinding(componentRef, parentSource, {
+    return resolveBinding(componentRef, parentSource, ancestors, {
       ...options,
       consumerArgs: curriedArgs,
     });
@@ -1061,6 +1224,19 @@ function resolveBinding(
   if (!expr.head) return TRANSPARENT;
 
   if (expr.head.type === 'VarHead') {
+    // `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 binderNode = nearestBinderFor(ancestors, expr.head.name);
+      if (binderNode) {
+        return resolveBlockParamReyield(binderNode, expr.tail[0]!, parentSource, options);
+      }
+    }
     return resolveByName(expr.head.name, parentSource, options);
   }
 
@@ -1307,3 +1483,15 @@ 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 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/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/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-fixtures/reyield-binder-thisprop-arg.gts b/test/glint-fixtures/reyield-binder-thisprop-arg.gts
new file mode 100644
index 0000000..a65f6ba
--- /dev/null
+++ b/test/glint-fixtures/reyield-binder-thisprop-arg.gts
@@ -0,0 +1,30 @@
+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;
+  Args: { elementTag: string };
+  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/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-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/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/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/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/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'
diff --git a/test/resolver/walk.test.ts b/test/resolver/walk.test.ts
index 8b82800..8141a6a 100644
--- a/test/resolver/walk.test.ts
+++ b/test/resolver/walk.test.ts
@@ -235,4 +235,176 @@ 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|`).
+    // 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');
+    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');
+  });
+
+  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');
+  });
+
+  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');
+  });
+
+  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');
+  });
+
+  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');
+  });
+
+  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');
+  });
+
+  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');
+  });
 });