diff --git a/doc/api.rst b/doc/api.rst
index ca1883280..20da66ff1 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -68,6 +68,64 @@ If a template defines blocks, they can be rendered individually via the
 
     echo $template->renderBlock('block_name', ['the' => 'variables', 'go' => 'here']);
 
+.. caution::
+
+    Rendering a block on its own does not run the template body, so macros
+    imported at the top level of the template are missing and the block fails
+    when it calls one. Move the ``import`` or ``from`` tag inside the block.
+    Rendering the whole template first also makes them available, but they then
+    keep the value they resolved to during that render.
+
+Composing Blocks
+----------------
+
+.. versionadded:: 3.29
+
+    The ``BlockChain`` class was introduced in Twig 3.29.
+
+Use ``BlockChain`` when a form, CMS field, data-grid or similar renderer needs
+to select blocks from several templates at runtime. Pass templates from the
+highest to the lowest precedence::
+
+    use Twig\BlockChain;
+
+    $blocks = new BlockChain($twig, [
+        'admin_theme.html.twig',
+        $twig->load('application_theme.html.twig'),
+        'base_theme.html.twig',
+    ]);
+
+    echo $blocks->renderBlock('field_row', ['field' => $field]);
+
+Twig considers each template's blocks, blocks imported with ``use`` and parents
+before moving to the next template. The first definition of each block wins.
+``parent()`` follows the local inheritance or ``use`` hierarchy of the block,
+while nested ``block()`` calls use the composed block set unless they name
+another template.
+
+``BlockChain`` composes blocks, not template bodies or macros. Because chained
+templates share the composed block set, only combine templates that are trusted
+to call one another's blocks. Chained blocks have the same top-level macro
+import limitation as blocks rendered directly.
+
+Every method takes the render context, and the whole chain is resolved against
+it, so a template using a dynamic ``{% extends %}`` behaves exactly as it would
+when rendered directly. The optional third constructor argument provides
+default variables for that resolution, which the render context can override::
+
+    $blocks = new BlockChain($twig, ['application_theme.html.twig'], [
+        'layout' => 'wide_layout.html.twig',
+    ]);
+
+    // resolved against wide_layout.html.twig
+    $blocks->getBlockNames();
+
+    // resolved against narrow_layout.html.twig
+    $blocks->getBlockNames(['layout' => 'narrow_layout.html.twig']);
+
+Pass the same context to ``hasBlock()``, ``getBlockNames()`` and
+``renderBlock()`` to keep them consistent.
+
 Streaming Templates
 -------------------
 
diff --git a/extra/twig-extra-bundle/DependencyInjection/Compiler/TwigCachePoolPass.php b/extra/twig-extra-bundle/DependencyInjection/Compiler/TwigCachePoolPass.php
new file mode 100644
index 000000000..a5bb216fd
--- /dev/null
+++ b/extra/twig-extra-bundle/DependencyInjection/Compiler/TwigCachePoolPass.php
@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of Twig.
+ *
+ * (c) Fabien Potencier
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Twig\Extra\TwigExtraBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\Cache\Adapter\TagAwareAdapterInterface;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Drops the "twig.cache" TagAwareAdapter when the pool it decorates is already tag aware.
+ *
+ * Wrapping a tag aware adapter in a TagAwareAdapter makes every read a miss, so the
+ * decorator must go when "cache.app" uses a natively tag aware adapter, the same way
+ * Symfony aliases "cache.app.taggable" to "cache.app" instead of decorating it.
+ *
+ * @internal
+ */
+final class TwigCachePoolPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (!$container->hasDefinition('twig.cache') || !$container->hasDefinition('.twig.cache.inner')) {
+            return;
+        }
+
+        $definition = $container->getDefinition('.twig.cache.inner');
+        $class = $definition->getClass();
+
+        while (null === $class && $definition instanceof ChildDefinition) {
+            $parent = $definition->getParent();
+
+            if (!$container->hasDefinition($parent) && !$container->hasAlias($parent)) {
+                return;
+            }
+
+            $definition = $container->findDefinition($parent);
+            $class = $definition->getClass();
+        }
+
+        if (!is_a($class ?? '', TagAwareAdapterInterface::class, true)) {
+            return;
+        }
+
+        $container->removeDefinition('twig.cache');
+        $container->setAlias('twig.cache', '.twig.cache.inner');
+    }
+}
diff --git a/extra/twig-extra-bundle/Tests/DependencyInjection/Compiler/TwigCachePoolPassTest.php b/extra/twig-extra-bundle/Tests/DependencyInjection/Compiler/TwigCachePoolPassTest.php
new file mode 100644
index 000000000..559215ab1
--- /dev/null
+++ b/extra/twig-extra-bundle/Tests/DependencyInjection/Compiler/TwigCachePoolPassTest.php
@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * This file is part of Twig.
+ *
+ * (c) Fabien Potencier
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Twig\Extra\TwigExtraBundle\Tests\DependencyInjection\Compiler;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\RedisTagAwareAdapter;
+use Symfony\Component\Cache\Adapter\TagAwareAdapter;
+use Symfony\Component\Filesystem\Filesystem;
+use Twig\Extra\TwigExtraBundle\Tests\Fixture\CacheKernel;
+
+class TwigCachePoolPassTest extends TestCase
+{
+    /** @var CacheKernel[] */
+    private array $kernels = [];
+
+    protected function tearDown(): void
+    {
+        foreach ($this->kernels as $kernel) {
+            (new Filesystem())->remove($kernel->getTempDir());
+        }
+
+        $this->kernels = [];
+    }
+
+    public function testThePoolIsDecoratedWhenTheAppAdapterIsNotTagAware(): void
+    {
+        $pools = $this->compileFor(null);
+
+        $this->assertSame(TagAwareAdapter::class, $pools['twig.cache']);
+        $this->assertSame(FilesystemAdapter::class, $pools['.twig.cache.inner']);
+        $this->assertNotSame($pools['cache.app.namespace'], $pools['.twig.cache.inner.namespace']);
+    }
+
+    public function testThePoolIsNotDecoratedWhenTheAppAdapterIsTagAware(): void
+    {
+        $pools = $this->compileFor('cache.adapter.redis_tag_aware');
+
+        $this->assertSame('@.twig.cache.inner', $pools['twig.cache']);
+        $this->assertSame(RedisTagAwareAdapter::class, $pools['.twig.cache.inner']);
+        $this->assertNotSame($pools['cache.app.namespace'], $pools['.twig.cache.inner.namespace']);
+    }
+
+    private function compileFor(?string $cacheAdapter): array
+    {
+        $this->kernels[] = $kernel = new CacheKernel($cacheAdapter);
+        $kernel->boot();
+
+        return $kernel->getContainer()->getParameter('twig_extra.test.cache_pools');
+    }
+}
diff --git a/extra/twig-extra-bundle/Tests/Fixture/CacheKernel.php b/extra/twig-extra-bundle/Tests/Fixture/CacheKernel.php
new file mode 100644
index 000000000..18dc54c86
--- /dev/null
+++ b/extra/twig-extra-bundle/Tests/Fixture/CacheKernel.php
@@ -0,0 +1,129 @@
+<?php
+
+/*
+ * This file is part of Twig.
+ *
+ * (c) Fabien Potencier
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Twig\Extra\TwigExtraBundle\Tests\Fixture;
+
+use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
+use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
+use Symfony\Bundle\FrameworkBundle\Test\NotificationAssertionsTrait;
+use Symfony\Bundle\TwigBundle\TwigBundle;
+use Symfony\Component\Config\Loader\LoaderInterface;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Compiler\PassConfig;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\HttpKernel\Kernel as BaseKernel;
+use Twig\Extra\TwigExtraBundle\TwigExtraBundle;
+
+/**
+ * Compiles a container for a given "framework.cache.app" adapter and exposes how the
+ * Twig cache pool ended up being wired in the "twig_extra.test.cache_pools" parameter.
+ */
+class CacheKernel extends BaseKernel
+{
+    use MicroKernelTrait;
+
+    private string $dir;
+
+    public function __construct(private ?string $cacheAdapter = null)
+    {
+        $this->dir = sys_get_temp_dir().'/twig-extra-bundle/'.bin2hex(random_bytes(6));
+
+        parent::__construct('test', false);
+    }
+
+    public function getCacheDir(): string
+    {
+        return $this->dir.'/cache';
+    }
+
+    public function getLogDir(): string
+    {
+        return $this->dir.'/log';
+    }
+
+    public function getProjectDir(): string
+    {
+        return __DIR__;
+    }
+
+    public function getTempDir(): string
+    {
+        return $this->dir;
+    }
+
+    public function registerBundles(): iterable
+    {
+        yield new FrameworkBundle();
+        yield new TwigBundle();
+        yield new TwigExtraBundle();
+    }
+
+    protected function build(ContainerBuilder $container): void
+    {
+        $container->addCompilerPass(new class implements CompilerPassInterface {
+            public function process(ContainerBuilder $container): void
+            {
+                $pools = [];
+                foreach (['twig.cache', '.twig.cache.inner', 'cache.app'] as $id) {
+                    if ($container->hasAlias($id)) {
+                        $pools[$id] = '@'.$container->getAlias($id);
+
+                        continue;
+                    }
+
+                    $definition = $container->getDefinition($id);
+                    $pools[$id] = $definition->getClass();
+
+                    // cache adapters take their namespace as their first string argument
+                    foreach ($definition->getArguments() as $argument) {
+                        if (\is_string($argument)) {
+                            $pools[$id.'.namespace'] = $argument;
+
+                            break;
+                        }
+                    }
+                }
+
+                $container->setParameter('twig_extra.test.cache_pools', $pools);
+            }
+        }, PassConfig::TYPE_BEFORE_REMOVING, -1000);
+    }
+
+    protected function configureContainer(ContainerBuilder $c, LoaderInterface $loader): void
+    {
+        $config = [
+            'secret' => 'S3CRET',
+            'router' => ['utf8' => true],
+            'http_method_override' => false,
+            'php_errors' => [
+                'log' => true,
+            ],
+        ];
+
+        // the "handle_all_throwables" option was introduced in FrameworkBundle 6.2 (and so was the NotificationAssertionsTrait)
+        if (trait_exists(NotificationAssertionsTrait::class)) {
+            $config['handle_all_throwables'] = true;
+        }
+
+        if (null !== $this->cacheAdapter) {
+            $config['cache'] = ['app' => $this->cacheAdapter];
+        }
+
+        $c->loadFromExtension('framework', $config);
+        $c->loadFromExtension('twig', [
+            'default_path' => __DIR__.'/views',
+        ]);
+    }
+
+    protected function configureRoutes($routes): void
+    {
+    }
+}
diff --git a/extra/twig-extra-bundle/TwigExtraBundle.php b/extra/twig-extra-bundle/TwigExtraBundle.php
index ee65985b6..5b08586ce 100644
--- a/extra/twig-extra-bundle/TwigExtraBundle.php
+++ b/extra/twig-extra-bundle/TwigExtraBundle.php
@@ -11,9 +11,11 @@
 
 namespace Twig\Extra\TwigExtraBundle;
 
+use Symfony\Component\DependencyInjection\Compiler\PassConfig;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 use Twig\Extra\TwigExtraBundle\DependencyInjection\Compiler\MissingExtensionSuggestorPass;
+use Twig\Extra\TwigExtraBundle\DependencyInjection\Compiler\TwigCachePoolPass;
 
 class TwigExtraBundle extends Bundle
 {
@@ -22,5 +24,7 @@ class TwigExtraBundle extends Bundle
         parent::build($container);
 
         $container->addCompilerPass(new MissingExtensionSuggestorPass());
+        // priority 64 so that it runs before Symfony's CachePoolPass (priority 32)
+        $container->addCompilerPass(new TwigCachePoolPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 64);
     }
 }
diff --git a/src/BlockChain.php b/src/BlockChain.php
new file mode 100644
index 000000000..e68f145da
--- /dev/null
+++ b/src/BlockChain.php
@@ -0,0 +1,191 @@
+<?php
+
+/*
+ * This file is part of Twig.
+ *
+ * (c) Fabien Potencier
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Twig;
+
+use Twig\Error\RuntimeError;
+
+/**
+ * Composes blocks from several templates without composing their bodies or macros.
+ */
+final class BlockChain
+{
+    /** @var list<Template> */
+    private array $templates = [];
+
+    /** @var list<Template> */
+    private array $lineage = [];
+
+    /** @var array<string, array{Template, string}> */
+    private array $blocks = [];
+
+    /**
+     * Whether the lineage can no longer move, making every further resolution pointless.
+     */
+    private bool $fixed = false;
+
+    /**
+     * @param iterable<string|TemplateWrapper> $templates Templates ordered from highest to lowest precedence
+     * @param array<string, mixed>             $context   Default variables used to resolve dynamic parent expressions
+     */
+    public function __construct(
+        private Environment $env,
+        iterable $templates,
+        private array $context = [],
+    ) {
+        foreach ($templates as $template) {
+            if (\is_string($template)) {
+                $template = $env->load($template);
+            }
+            if (!$template instanceof TemplateWrapper) {
+                throw new \TypeError(\sprintf('Block chain templates must be strings or "%s" instances, "%s" given.', TemplateWrapper::class, get_debug_type($template)));
+            }
+
+            $template = $template->unwrap();
+            if (!$template->isOwnedBy($env)) {
+                throw new \LogicException('A block chain cannot contain templates from different Twig environments.');
+            }
+
+            $this->templates[] = $template;
+        }
+
+        if (!$this->templates) {
+            throw new \InvalidArgumentException('A block chain requires at least one template.');
+        }
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     */
+    public function hasBlock(string $name, array $context = []): bool
+    {
+        $blocks = $this->fixed ? $this->blocks : $this->resolveBlocks($context + $this->context + $this->env->getGlobals());
+
+        return isset($blocks[$name]);
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return string[]
+     */
+    public function getBlockNames(array $context = []): array
+    {
+        return array_keys($this->fixed ? $this->blocks : $this->resolveBlocks($context + $this->context + $this->env->getGlobals()));
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return iterable<scalar|\Stringable|null>
+     */
+    public function streamBlock(string $name, array $context = []): iterable
+    {
+        $context += $this->context + $this->env->getGlobals();
+        $blocks = $this->fixed ? $this->blocks : $this->resolveBlocks($context);
+        if (!isset($blocks[$name])) {
+            $this->throwUnknownBlock($name);
+        }
+
+        yield from $this->templates[0]->yieldBlock($name, $context, $blocks);
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     */
+    public function renderBlock(string $name, array $context = []): string
+    {
+        $context += $this->context + $this->env->getGlobals();
+        $blocks = $this->fixed ? $this->blocks : $this->resolveBlocks($context);
+        if (!isset($blocks[$name])) {
+            $this->throwUnknownBlock($name);
+        }
+
+        return $this->templates[0]->renderBlock($name, $context, $blocks);
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     */
+    public function displayBlock(string $name, array $context = []): void
+    {
+        $context += $this->context + $this->env->getGlobals();
+        $blocks = $this->fixed ? $this->blocks : $this->resolveBlocks($context);
+        if (!isset($blocks[$name])) {
+            $this->throwUnknownBlock($name);
+        }
+
+        $this->templates[0]->displayBlock($name, $context, $blocks);
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<string, array{Template, string}>
+     */
+    private function resolveBlocks(array $context): array
+    {
+        [$lineage, $this->fixed] = $this->resolveLineage($context);
+
+        if ($lineage === $this->lineage) {
+            return $this->blocks;
+        }
+
+        $blocks = [];
+        foreach ($lineage as $template) {
+            foreach ($template->getBlocks() as $name => $block) {
+                $blocks[$name] ??= $block;
+            }
+        }
+
+        $this->lineage = $lineage;
+
+        return $this->blocks = $blocks;
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array{list<Template>, bool}
+     */
+    private function resolveLineage(array $context): array
+    {
+        $lineage = [];
+        $fixed = true;
+
+        foreach ($this->templates as $template) {
+            $seen = [];
+            do {
+                if (isset($seen[$id = spl_object_id($template)])) {
+                    throw new \LogicException(\sprintf('Circular template inheritance detected while building a block chain from "%s".', $template->getTemplateName()));
+                }
+                $seen[$id] = true;
+                $lineage[] = $template;
+
+                $parent = $template->getParent($context);
+                $fixed = $fixed && $template->hasFixedParent();
+
+                // a dynamic parent expression can evaluate to a template from another environment
+                $template = $parent instanceof TemplateWrapper ? $parent->unwrap() : $parent;
+                if (false !== $template && !$template->isOwnedBy($this->env)) {
+                    throw new \LogicException('A block chain cannot contain templates from different Twig environments.');
+                }
+            } while (false !== $template);
+        }
+
+        return [$lineage, $fixed];
+    }
+
+    private function throwUnknownBlock(string $name): never
+    {
+        throw new RuntimeError(\sprintf('Block "%s" on template "%s" does not exist.', $name, $this->templates[0]->getTemplateName()), -1, $this->templates[0]->getSourceContext());
+    }
+}
diff --git a/src/Node/CheckSecurityCallNode.php b/src/Node/CheckSecurityCallNode.php
index a32a14fd7..a3011ef17 100644
--- a/src/Node/CheckSecurityCallNode.php
+++ b/src/Node/CheckSecurityCallNode.php
@@ -15,6 +15,9 @@ use Twig\Attribute\YieldReady;
 use Twig\Compiler;
 
 /**
+ * Wires the security checker at the very top of the template constructor, as
+ * the constructor resolves `use` traits before the sandbox could check them.
+ *
  * @author Fabien Potencier <fabien@symfony.com>
  */
 #[YieldReady]
@@ -23,7 +26,7 @@ class CheckSecurityCallNode extends Node
     public function compile(Compiler $compiler): void
     {
         $compiler
-            ->write("\$this->sandbox = \$this->extensions[SandboxExtension::class]->getChecker();\n")
+            ->write("\$this->sandbox = \$env->getExtension(SandboxExtension::class)->getChecker();\n")
         ;
     }
 }
diff --git a/src/Node/CheckSecurityNode.php b/src/Node/CheckSecurityNode.php
index 2975f0f03..e13a54b49 100644
--- a/src/Node/CheckSecurityNode.php
+++ b/src/Node/CheckSecurityNode.php
@@ -43,6 +43,32 @@ class CheckSecurityNode extends Node
 
     public function compile(Compiler $compiler): void
     {
+        if (isset($this->usedTags['use'])) {
+            $compiler
+                ->write("\n")
+                ->write("protected function checkTraitsAllowed(): void\n")
+                ->write("{\n")
+                ->indent()
+                ->write("if (!\$this->sandbox->isSandboxed(\$this->source)) {\n")
+                ->indent()
+                ->write("return;\n")
+                ->outdent()
+                ->write("}\n\n")
+                ->write("try {\n")
+                ->indent()
+                ->write("\$this->sandbox->checkSecurity(['use'], [], [], [], \$this->source);\n")
+                ->outdent()
+                ->write("} catch (SecurityNotAllowedTagError \$e) {\n")
+                ->indent()
+                ->write('$e->setTemplateLine(')->repr($this->usedTags['use'])->raw(");\n\n")
+                ->write("throw \$e;\n")
+                ->outdent()
+                ->write("}\n")
+                ->outdent()
+                ->write("}\n")
+            ;
+        }
+
         $compiler
             ->write("\n")
             ->write("public function ensureSecurityChecked(): void\n")
diff --git a/src/Node/ModuleNode.php b/src/Node/ModuleNode.php
index f843601cd..e41be910d 100644
--- a/src/Node/ModuleNode.php
+++ b/src/Node/ModuleNode.php
@@ -121,17 +121,18 @@ final class ModuleNode extends Node implements CoercesChildrenToStringInterface
         ;
 
         if ($parent instanceof ConstantExpression) {
-            $compiler->subcompile($parent);
-        } else {
-            $compiler
-                ->raw('$this->load(')
-                ->subcompile($parent)
-                ->raw(', ')
-                ->repr($parent->getTemplateLine())
-                ->raw(')')
-            ;
+            // a constant parent never depends on the context, so resolve it once
+            $compiler->raw('$this->parent ??= ');
         }
 
+        $compiler
+            ->raw('$this->load(')
+            ->subcompile($parent)
+            ->raw(', ')
+            ->repr($parent->getTemplateLine())
+            ->raw(')')
+        ;
+
         $compiler
             ->raw(";\n")
             ->outdent()
@@ -196,7 +197,8 @@ final class ModuleNode extends Node implements CoercesChildrenToStringInterface
 
         $countTraits = \count($this->getNode('traits'));
         if ($countTraits) {
-            // traits
+            $compiler->write("\$this->ensureTraitsAllowed();\n\n");
+
             foreach ($this->getNode('traits') as $i => $trait) {
                 $node = $trait->getNode('template');
 
diff --git a/src/NodeVisitor/SandboxNodeVisitor.php b/src/NodeVisitor/SandboxNodeVisitor.php
index 8050ead38..4fabf6e42 100644
--- a/src/NodeVisitor/SandboxNodeVisitor.php
+++ b/src/NodeVisitor/SandboxNodeVisitor.php
@@ -124,7 +124,7 @@ final class SandboxNodeVisitor implements NodeVisitorInterface
         if ($node instanceof ModuleNode) {
             $this->inAModule = false;
 
-            $node->setNode('constructor_end', new Nodes([new CheckSecurityCallNode(), $node->getNode('constructor_end')]));
+            $node->setNode('constructor_start', new Nodes([new CheckSecurityCallNode(), $node->getNode('constructor_start')]));
             $node->setNode('class_end', new Nodes([new CheckSecurityNode($this->filters, $this->tags, $this->functions, $this->tests), $node->getNode('class_end')]));
         }
 
diff --git a/src/Template.php b/src/Template.php
index f68269246..d58ee8abb 100644
--- a/src/Template.php
+++ b/src/Template.php
@@ -311,6 +311,23 @@ abstract class Template
         return $this;
     }
 
+    /**
+     * @internal
+     */
+    public function isOwnedBy(Environment $env): bool
+    {
+        return $this->env === $env;
+    }
+
+    /**
+     * Returns whether getParent() has stopped depending on the context, which
+     * only ever happens for a template with no parent or with a constant one.
+     */
+    public function hasFixedParent(): bool
+    {
+        return null !== $this->parent;
+    }
+
     /**
      * Returns all blocks.
      *
@@ -444,6 +461,31 @@ abstract class Template
     {
     }
 
+    /**
+     * Checks the "use" tag against the sandbox policy.
+     *
+     * The constructor resolves "use" traits eagerly, which reaches the loader,
+     * so that tag alone is checked here; the rest of the policy still runs at
+     * render time.
+     *
+     * @internal
+     */
+    public function ensureTraitsAllowed(): void
+    {
+        try {
+            $this->checkTraitsAllowed();
+        } catch (\Throwable $e) {
+            $this->handleException($e);
+        }
+    }
+
+    /**
+     * @internal
+     */
+    protected function checkTraitsAllowed(): void
+    {
+    }
+
     private function handleException(\Throwable $error): never
     {
         if ($error instanceof Error) {
diff --git a/tests/BlockChainTest.php b/tests/BlockChainTest.php
new file mode 100644
index 000000000..f096575fa
--- /dev/null
+++ b/tests/BlockChainTest.php
@@ -0,0 +1,693 @@
+<?php
+
+/*
+ * This file is part of Twig.
+ *
+ * (c) Fabien Potencier
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Twig\Tests;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use Twig\BlockChain;
+use Twig\Environment;
+use Twig\Error\RuntimeError;
+use Twig\Extension\ProfilerExtension;
+use Twig\Extension\SandboxExtension;
+use Twig\Loader\ArrayLoader;
+use Twig\Profiler\Profile;
+use Twig\Sandbox\SecurityNotAllowedFilterError;
+use Twig\Sandbox\SecurityPolicy;
+use Twig\Source;
+use Twig\Template;
+use Twig\TemplateWrapper;
+
+class BlockChainTest extends TestCase
+{
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testComposesCompleteTemplateLineagesInPrecedenceOrder(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme1' => '{% extends "parent1" %}{% block first %}theme1{% endblock %}',
+            'parent1' => '{% block shared %}parent1{% endblock %}{% block parent1 %}parent1{% endblock %}',
+            'theme2' => '{% extends "parent2" %}{% block shared %}theme2{% endblock %}{% block second %}theme2{% endblock %}',
+            'parent2' => '{% block parent2 %}parent2{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+
+        $chain = new BlockChain($twig, ['theme1', $twig->load('theme2')]);
+
+        $this->assertSame(['first', 'shared', 'parent1', 'second', 'parent2'], $chain->getBlockNames());
+        $this->assertTrue($chain->hasBlock('shared'));
+        $this->assertFalse($chain->hasBlock('missing'));
+        $this->assertSame('parent1', $chain->renderBlock('shared'));
+        $this->assertSame('theme2', $chain->renderBlock('second'));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testNestedBlocksUseTheComposedSetAndParentUsesTheRenderContextLineage(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% block field %}theme/{{ parent() }}/{{ block("suffix") }}{% endblock %}',
+            'parent1' => '{% block field %}parent1{% endblock %}',
+            'parent2' => '{% block field %}parent2{% endblock %}',
+            'suffix' => '{% block suffix %}suffix{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+
+        $chain = new BlockChain($twig, ['theme', 'suffix'], ['parent' => 'parent1']);
+
+        $this->assertSame('theme/parent1/suffix', $chain->renderBlock('field'));
+        $this->assertSame('theme/parent2/suffix', $chain->renderBlock('field', ['parent' => 'parent2']));
+    }
+
+    public function testExplicitTemplateBlockCallsResolveOutsideTheChainNamespace(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% block field %}{{ block("suffix", "explicit") }}{% endblock %}',
+            'chain' => '{% block suffix %}chain{% endblock %}',
+            'explicit' => '{% block suffix %}explicit{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+
+        $chain = new BlockChain($twig, ['theme', 'chain']);
+
+        $this->assertSame('explicit', $chain->renderBlock('field'));
+    }
+
+    public function testTheConstructorContextIsADefaultTheRenderContextCanOverride(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% block field %}{{ parent() }}{% endblock %}',
+            'parent1' => '{% block field %}one{% endblock %}',
+            'parent2' => '{% block field %}two{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent1']);
+
+        $this->assertSame('one', $chain->renderBlock('field'));
+        $this->assertSame('two', $chain->renderBlock('field', ['parent' => 'parent2']));
+        $this->assertSame('one', $chain->renderBlock('field'));
+    }
+
+    public function testIntrospectionAndRenderingAgreeOnTheSameContext(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% block field %}{{ parent() }}{% endblock %}',
+            'parent1' => '{% block field %}one{% endblock %}{% block only1 %}{% endblock %}',
+            'parent2' => '{% block field %}two{% endblock %}{% block only2 %}{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent1']);
+
+        $this->assertSame(['field', 'only1'], $chain->getBlockNames());
+        $this->assertTrue($chain->hasBlock('only1'));
+        $this->assertFalse($chain->hasBlock('only2'));
+
+        $context = ['parent' => 'parent2'];
+        $this->assertSame(['field', 'only2'], $chain->getBlockNames($context));
+        $this->assertFalse($chain->hasBlock('only1', $context));
+        $this->assertTrue($chain->hasBlock('only2', $context));
+        $this->assertSame('two', $chain->renderBlock('field', $context));
+    }
+
+    public function testRenderingThroughTheChainDoesNotChangeTheLoadedTemplate(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% block field %}{{ parent() }}{% endblock %}',
+            'parent1' => '{% block field %}one{% endblock %}',
+            'parent2' => '{% block field %}two{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+        $template = $twig->load('theme');
+        $chain = new BlockChain($twig, [$template], ['parent' => 'parent1']);
+
+        $this->assertSame('one', $chain->renderBlock('field'));
+        $this->assertSame('two', $template->renderBlock('field', ['parent' => 'parent2']));
+        $this->assertSame('one', $chain->renderBlock('field'));
+    }
+
+    public function testStructuralContextIncludesEnvironmentGlobals(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends layout %}{% block field %}{{ parent() }}{% endblock %}',
+            'parent' => '{% block field %}parent{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+        $twig->addGlobal('layout', 'parent');
+
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame('parent', $chain->renderBlock('field'));
+    }
+
+    public function testTraitAliasesKeepTheirLocalParentLineage(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'base_trait' => '{% block field %}base{% endblock %}',
+            'trait' => '{% use "base_trait" %}{% block field %}trait/{{ parent() }}{% endblock %}',
+            'theme' => '{% use "trait" with field as aliased %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame(['aliased'], $chain->getBlockNames());
+        $this->assertSame('trait/base', $chain->renderBlock('aliased'));
+    }
+
+    public function testRenderCapturesLegacyEchoingBlocks(): void
+    {
+        $twig = new Environment(new ArrayLoader(), ['use_yield' => false]);
+        $chain = new BlockChain($twig, [new TemplateWrapper($twig, new EchoingBlockChainTemplate($twig))]);
+
+        $this->assertSame('echo/yield', $chain->renderBlock('field'));
+    }
+
+    public function testRenderRestoresOutputBuffersOnError(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% block field %}{% set captured %}{{ missing.value }}{% endset %}{% endblock %}',
+        ]), ['strict_variables' => true, 'use_yield' => false]);
+        $chain = new BlockChain($twig, ['theme']);
+        $level = ob_get_level();
+
+        try {
+            $chain->renderBlock('field');
+            $this->fail('Rendering the block must fail.');
+        } catch (RuntimeError) {
+            $actualLevel = ob_get_level();
+        } finally {
+            while (ob_get_level() > $level) {
+                ob_end_clean();
+            }
+        }
+
+        $this->assertSame($level, $actualLevel);
+    }
+
+    public function testRenderingDisplayingAndStreamingAddGlobals(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% block field %}{{ local }}:{{ global|default("none") }}{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+        $twig->addGlobal('global', 'GLOBAL');
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame('LOCAL:GLOBAL', $chain->renderBlock('field', ['local' => 'LOCAL']));
+
+        ob_start();
+        $chain->displayBlock('field', ['local' => 'LOCAL']);
+        $this->assertSame('LOCAL:GLOBAL', ob_get_clean());
+
+        $streamed = '';
+        foreach ($chain->streamBlock('field', ['local' => 'LOCAL']) as $data) {
+            $streamed .= $data;
+        }
+        $this->assertSame('LOCAL:GLOBAL', $streamed);
+    }
+
+    public function testRejectsInvalidBlockDefinitions(): void
+    {
+        $twig = new Environment(new ArrayLoader());
+        $template = new class($twig) extends EchoingBlockChainTemplate {
+            public function __construct(Environment $env)
+            {
+                parent::__construct($env);
+                $this->blocks = ['field' => [new \stdClass(), 'block_field']];
+            }
+        };
+        $chain = new BlockChain($twig, [new TemplateWrapper($twig, $template)]);
+        $this->assertSame(['field'], $chain->getBlockNames());
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('A block must be a method on a \Twig\Template instance.');
+
+        $chain->renderBlock('field');
+    }
+
+    public function testRejectsTemplatesThatAreNotStringsOrWrappers(): void
+    {
+        $twig = new Environment(new ArrayLoader(['theme' => '']));
+
+        $this->expectException(\TypeError::class);
+        $this->expectExceptionMessage('Block chain templates must be strings or "Twig\TemplateWrapper" instances, "stdClass" given.');
+
+        new BlockChain($twig, [new \stdClass()]);
+    }
+
+    public function testRejectsWrappersFromAnotherEnvironment(): void
+    {
+        $twig = new Environment(new ArrayLoader(['theme' => '']));
+        $other = new Environment(new ArrayLoader(['theme' => '']));
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('A block chain cannot contain templates from different Twig environments.');
+
+        new BlockChain($twig, [$other->load('theme')]);
+    }
+
+    public function testRejectsWrappersThatHideATemplateFromAnotherEnvironment(): void
+    {
+        $twig = new Environment(new ArrayLoader(['theme' => '']));
+        $other = new Environment(new ArrayLoader(['theme' => '']));
+        $wrapper = new TemplateWrapper($twig, $other->load('theme')->unwrap());
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('A block chain cannot contain templates from different Twig environments.');
+
+        new BlockChain($twig, [$wrapper]);
+    }
+
+    public function testRejectsDynamicParentsFromAnotherEnvironment(): void
+    {
+        $twig = new Environment(new ArrayLoader(['theme' => '{% extends parent %}']));
+        $other = new Environment(new ArrayLoader(['parent' => '']));
+        $chain = new BlockChain($twig, ['theme'], ['parent' => $other->load('parent')]);
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('A block chain cannot contain templates from different Twig environments.');
+
+        $chain->getBlockNames();
+    }
+
+    public function testDynamicParentSecurityIsCheckedWhenTheLineageIsResolved(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent|upper %}',
+            'PARENT' => '',
+        ]));
+        $twig->addExtension(new SandboxExtension(new SecurityPolicy(['extends']), true));
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent']);
+
+        $this->expectException(SecurityNotAllowedFilterError::class);
+
+        $chain->getBlockNames();
+    }
+
+    public function testDefiningTemplateSecurityIsCheckedDuringRendering(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% block field %}{{ value|upper }}{% endblock %}',
+        ]));
+        $twig->addExtension(new SandboxExtension(new SecurityPolicy(['block']), true));
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->expectException(SecurityNotAllowedFilterError::class);
+
+        $chain->renderBlock('field', ['value' => 'value']);
+    }
+
+    public function testSandboxPolicyChangesAreObservedAfterConstruction(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'policy_theme' => '{% extends "parent" %}{% block field %}{{ value|upper }}{% endblock %}',
+            'parent' => '',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+        $sandbox = new SandboxExtension(new SecurityPolicy(['extends', 'block'], ['upper']), true);
+        $twig->addExtension($sandbox);
+        $chain = new BlockChain($twig, ['policy_theme']);
+
+        $this->assertSame('VALUE', $chain->renderBlock('field', ['value' => 'value']));
+
+        $sandbox->setSecurityPolicy(new SecurityPolicy(['extends', 'block']));
+        $this->expectException(SecurityNotAllowedFilterError::class);
+
+        $chain->renderBlock('field', ['value' => 'value']);
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testSandboxPolicyChangesAreCheckedOnIntermediateParents(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "middle" %}{% block field %}{{ parent() }}{% endblock %}',
+            'middle' => '{% extends parent|upper %}',
+            'GRANDPARENT' => '{% block field %}safe{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $sandbox = new SandboxExtension(new SecurityPolicy(['extends', 'block'], ['upper'], allowedFunctions: ['parent']), true);
+        $twig->addExtension($sandbox);
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'grandparent']);
+
+        $this->assertSame('safe', $chain->renderBlock('field'));
+
+        $sandbox->setSecurityPolicy(new SecurityPolicy(['extends', 'block'], allowedFunctions: ['parent']));
+        $this->expectException(SecurityNotAllowedFilterError::class);
+
+        $chain->renderBlock('field');
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testImportedMacroNamespacesObserveSandboxPolicyChanges(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "layout" %}{% import "macros" as macros %}{% block field %}{{ macros.label(value) }}{% endblock %}',
+            'layout' => '{{ block("field") }}',
+            'macros' => '{% macro label(value) %}{{ value|upper }}{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $sandbox = new SandboxExtension(new SecurityPolicy(['extends', 'import', 'block', 'macro'], ['upper'], allowedFunctions: ['block']), true);
+        $twig->addExtension($sandbox);
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame('VALUE', $twig->render('theme', ['value' => 'value']));
+        $this->assertSame('VALUE', $chain->renderBlock('field', ['value' => 'value']));
+
+        $sandbox->setSecurityPolicy(new SecurityPolicy(['extends', 'import', 'block', 'macro'], allowedFunctions: ['block']));
+        $this->expectException(SecurityNotAllowedFilterError::class);
+
+        $chain->renderBlock('field', ['value' => 'value']);
+    }
+
+    public function testProfilerKeepsTheDefiningTemplateAndBlockAttribution(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "parent" %}{% block field %}field{% endblock %}',
+            'parent' => '',
+        ]), ['use_yield' => true]);
+        $profile = new Profile();
+        $twig->addExtension(new ProfilerExtension($profile));
+        $chain = new BlockChain($twig, ['theme']);
+
+        $chain->renderBlock('field');
+
+        $profiles = $profile->getProfiles();
+        $this->assertCount(1, $profiles);
+        $this->assertSame('theme', $profiles[0]->getTemplate());
+        $this->assertSame(Profile::BLOCK, $profiles[0]->getType());
+        $this->assertSame('field', $profiles[0]->getName());
+    }
+
+    public function testMacrosStayOwnedByTheirDefiningTemplate(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme1' => '{% macro label() %}one{% endmacro %}{% block field %}{{ _self.label() }}{% endblock %}',
+            'theme2' => '{% macro label() %}two{% endmacro %}{% block field %}{{ _self.label() }}{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+
+        $chain = new BlockChain($twig, ['theme1', 'theme2']);
+
+        $this->assertSame('one', $chain->renderBlock('field'));
+    }
+
+    public function testInheritedMacroLookupUsesTheRenderContextLineage(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% block field %}{{ _self.label() }}{% endblock %}',
+            'parent1' => '{% macro label() %}one{% endmacro %}',
+            'parent2' => '{% macro label() %}two{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent1']);
+
+        $this->assertSame('one', $chain->renderBlock('field'));
+        $this->assertSame('two', $chain->renderBlock('field', ['parent' => 'parent2']));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testSelfMacroImportsUseTheRenderContextLineage(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% import _self as own %}{% block field %}{{ own.label() }}{% endblock %}',
+            'parent1' => '{% macro label() %}one{% endmacro %}{{ block("field") }}',
+            'parent2' => '{% macro label() %}two{% endmacro %}{{ block("field") }}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent1']);
+
+        $this->assertSame('two', $twig->render('theme', ['parent' => 'parent2']));
+        $this->assertSame('one', $chain->renderBlock('field'));
+        $this->assertSame('two', $chain->renderBlock('field', ['parent' => 'parent2']));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testFromSelfImportsResolveThroughTheLineage(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "parent" %}{% from _self import label %}{% macro wrapped() %}{{ label() }}{% endmacro %}{% block field %}{{ label() }}/{{ _self.wrapped() }}{% endblock %}',
+            'parent' => '{% macro label() %}one{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $this->assertSame('', $twig->render('theme'));
+
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame('one/one', $chain->renderBlock('field'));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testImportedMacroNamespacesKeepTheirOwnLineage(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% import parent as inherited %}{% block field %}{{ inherited.label() }}{% endblock %}',
+            'parent1' => '{% macro label() %}one{% endmacro %}{{ block("field") }}',
+            'parent2' => '{% macro label() %}two{% endmacro %}{{ block("field") }}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $this->assertSame('two', $twig->render('theme', ['parent' => 'parent2']));
+
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent1']);
+
+        $this->assertSame('two', $chain->renderBlock('field'));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testModuleImportsFollowTheDefiningTemplateBodyState(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "layout" %}{% import helper as macros %}{% block field %}{{ macros.label() }}{% endblock %}',
+            'layout' => '{{ block("field") }}',
+            'macros1' => '{% macro label() %}one{% endmacro %}',
+            'macros2' => '{% macro label() %}two{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $chain = new BlockChain($twig, ['theme']);
+
+        try {
+            $chain->renderBlock('field', ['helper' => 'macros1']);
+            $this->fail('Rendering an uninitialized import must fail.');
+        } catch (RuntimeError) {
+        }
+
+        $this->assertSame('one', $twig->render('theme', ['helper' => 'macros1']));
+        $this->assertSame('one', $chain->renderBlock('field'));
+        $this->assertSame('two', $twig->render('theme', ['helper' => 'macros2']));
+        $this->assertSame('two', $chain->renderBlock('field'));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testSelfMacroImportsInMacroBodiesResolveThroughTheLineage(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "parent" %}{% import _self as own %}{% macro wrapped() %}{{ own.label() }}{% endmacro %}{% block field %}{{ _self.wrapped() }}{% endblock %}',
+            'parent' => '{% macro label() %}one{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame('', $twig->render('theme'));
+        $this->assertSame('one', $chain->renderBlock('field'));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testMacroBodiesCannotResolveADynamicParentJustLikeADirectRender(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% import _self as own %}{% macro wrapped() %}{{ own.label() }}{% endmacro %}{% block field %}{{ _self.wrapped() }}{% endblock %}',
+            'parent' => '{% macro label() %}one{% endmacro %}{{ block("field") }}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $chain = new BlockChain($twig, ['theme'], ['parent' => 'parent']);
+
+        // a macro body only receives the macro arguments, so the "parent" variable is out of reach either way
+        $this->expectException(RuntimeError::class);
+
+        try {
+            $twig->render('theme', ['parent' => 'parent']);
+            $this->fail('Rendering the template directly must fail.');
+        } catch (RuntimeError) {
+        }
+
+        $chain->renderBlock('field');
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testMacroBodiesObserveImportUpdatesAfterConstruction(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "layout" %}{% import helper as macros %}{% macro wrapped() %}{{ macros.label() }}{% endmacro %}{% block field %}{{ _self.wrapped() }}{% endblock %}',
+            'layout' => '{{ block("field") }}',
+            'macros1' => '{% macro label() %}one{% endmacro %}',
+            'macros2' => '{% macro label() %}two{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->assertSame('one', $twig->render('theme', ['helper' => 'macros1']));
+        $this->assertSame('one', $chain->renderBlock('field'));
+        $this->assertSame('two', $twig->render('theme', ['helper' => 'macros2']));
+        $this->assertSame('two', $chain->renderBlock('field'));
+    }
+
+    /**
+     * @dataProvider yieldModes
+     */
+    #[DataProvider('yieldModes')]
+    public function testPreWarmedExternalMacroImportsAreNotReboundByChainOrder(bool $useYield): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends "layout" %}{% import "macros" as macros %}{% block field %}{{ macros.label() }}{% endblock %}',
+            'layout' => '{{ block("field") }}',
+            'macros' => '{% extends macro_parent %}',
+            'macros1' => '{% macro label() %}one{% endmacro %}',
+            'macros2' => '{% macro label() %}two{% endmacro %}',
+        ]), ['autoescape' => false, 'use_yield' => $useYield]);
+        $this->assertSame('two', $twig->render('theme', ['macro_parent' => 'macros2']));
+
+        $context = ['macro_parent' => 'macros1'];
+        $renderContext = ['macro_parent' => 'macros2'];
+
+        $this->assertSame('two', (new BlockChain($twig, ['macros', 'theme'], $context))->renderBlock('field', $renderContext));
+        $this->assertSame('two', (new BlockChain($twig, ['theme', 'macros'], $context))->renderBlock('field', $renderContext));
+    }
+
+    public function testChainsWithDifferentDynamicParentsCanBeStreamedInterleaved(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => '{% extends parent %}{% block field %}before/{{ parent() }}/after{% endblock %}',
+            'parent1' => '{% block field %}one{% endblock %}',
+            'parent2' => '{% block field %}two{% endblock %}',
+        ]), ['autoescape' => false, 'use_yield' => true]);
+
+        $stream1 = (new BlockChain($twig, ['theme'], ['parent' => 'parent1']))->streamBlock('field');
+        $stream2 = (new BlockChain($twig, ['theme'], ['parent' => 'parent2']))->streamBlock('field');
+
+        $output1 = $output2 = '';
+        $stream1->rewind();
+        $stream2->rewind();
+        while ($stream1->valid() || $stream2->valid()) {
+            if ($stream1->valid()) {
+                $output1 .= $stream1->current();
+                $stream1->next();
+            }
+            if ($stream2->valid()) {
+                $output2 .= $stream2->current();
+                $stream2->next();
+            }
+        }
+
+        $this->assertSame('before/one/after', $output1);
+        $this->assertSame('before/two/after', $output2);
+    }
+
+    public function testErrorsKeepTheDefiningSourceAndLine(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'theme' => "{% block field %}\n{{ missing.value }}\n{% endblock %}",
+        ]), ['strict_variables' => true, 'use_yield' => true]);
+        $chain = new BlockChain($twig, ['theme']);
+
+        try {
+            $chain->renderBlock('field');
+            $this->fail('Rendering must fail.');
+        } catch (RuntimeError $e) {
+            $this->assertSame('theme', $e->getSourceContext()->getName());
+            $this->assertSame(2, $e->getTemplateLine());
+        }
+    }
+
+    public function testUnknownBlockUsesTheFirstTemplateAsErrorContext(): void
+    {
+        $twig = new Environment(new ArrayLoader(['theme' => '']));
+        $chain = new BlockChain($twig, ['theme']);
+
+        $this->expectException(RuntimeError::class);
+        $this->expectExceptionMessage('Block "missing" on template "theme" does not exist in "theme".');
+
+        $chain->renderBlock('missing');
+    }
+
+    public function testCircularInheritanceIsRejected(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'one' => '{% extends "two" %}',
+            'two' => '{% extends "one" %}',
+        ]));
+        $chain = new BlockChain($twig, ['one']);
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('Circular template inheritance detected while building a block chain from "one".');
+
+        $chain->getBlockNames();
+    }
+
+    public function testRequiresAtLeastOneTemplate(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('A block chain requires at least one template.');
+
+        new BlockChain(new Environment(new ArrayLoader()), []);
+    }
+
+    public static function yieldModes(): iterable
+    {
+        yield 'echo and yield' => [false];
+        yield 'yield only' => [true];
+    }
+}
+
+class EchoingBlockChainTemplate extends Template
+{
+    public function __construct(Environment $env)
+    {
+        parent::__construct($env);
+        $this->parent = false;
+        $this->blocks = ['field' => [$this, 'block_field']];
+    }
+
+    public function block_field(array $context, array $blocks = []): iterable
+    {
+        echo 'echo/';
+        yield 'yield';
+    }
+
+    public function getTemplateName(): string
+    {
+        return 'echoing';
+    }
+
+    public function getDebugInfo(): array
+    {
+        return [];
+    }
+
+    public function getSourceContext(): Source
+    {
+        return new Source('', 'echoing');
+    }
+
+    protected function doDisplay(array $context, array $blocks = []): iterable
+    {
+        yield from [];
+    }
+}
diff --git a/tests/Extension/SandboxTest.php b/tests/Extension/SandboxTest.php
index 5dc3363fe..0e8dadadb 100644
--- a/tests/Extension/SandboxTest.php
+++ b/tests/Extension/SandboxTest.php
@@ -223,6 +223,9 @@ class SandboxTest extends TestCase
     {
         yield ['extends', '{% extends "1_empty" %}'];
         yield ['use', '{% use "1_empty" %}'];
+        yield 'use of a missing template is rejected before the loader is reached' => ['use', '{% use "does_not_exist" %}'];
+        yield 'use of a missing block is rejected before the trait is resolved' => ['use', '{% use "1_layout" with does_not_exist as alias %}'];
+        yield 'use of a non-traitable template is rejected before the trait is resolved' => ['use', '{% use "1_child" %}'];
     }
 
     #[DataProvider('getStrictSandboxRejectsGrandfatheredFunctionsTests')]
diff --git a/tests/Node/ModuleTest.php b/tests/Node/ModuleTest.php
index 3722826c3..4f038d08e 100644
--- a/tests/Node/ModuleTest.php
+++ b/tests/Node/ModuleTest.php
@@ -213,7 +213,7 @@ class __TwigTemplate_%x extends Template
     protected function doGetParent(array \$context): bool|string|Template|TemplateWrapper
     {
         // line 1
-        return "layout.twig";
+        return \$this->parent ??= \$this->load("layout.twig", 1);
     }
 
     protected function doDisplay(array \$context, array \$blocks = []): iterable
diff --git a/tests/Sandbox/SandboxTest.php b/tests/Sandbox/SandboxTest.php
index 216cfd086..5f8f88fdc 100644
--- a/tests/Sandbox/SandboxTest.php
+++ b/tests/Sandbox/SandboxTest.php
@@ -13,6 +13,7 @@ namespace Twig\Tests\Sandbox;
 
 use PHPUnit\Framework\TestCase;
 use Twig\Environment;
+use Twig\Error\RuntimeError;
 use Twig\Extension\SandboxExtension;
 use Twig\Loader\ArrayLoader;
 use Twig\Markup;
@@ -236,6 +237,65 @@ class SandboxTest extends TestCase
         $denying->render('index');
     }
 
+    public function testTheUseTagMustBeAllowed(): void
+    {
+        $templates = [
+            'index' => '{% use "blocks" with content as base_content %}{{ block("base_content") }}',
+            'blocks' => '{% block content %}trait content{% endblock %}',
+        ];
+
+        $allowing = new Sandbox(self::env($templates), self::strictPolicy(tags: ['use', 'block'], functions: ['block']));
+        $this->assertSame('trait content', $allowing->render('index'));
+
+        $denying = new Sandbox(self::env(['index' => '{% use "missing" with content as base_content %}']), self::strictPolicy());
+        $this->expectException(SecurityNotAllowedTagError::class);
+        $this->expectExceptionMessage('Tag "use" is not allowed');
+        $denying->render('index');
+    }
+
+    public function testTheUseTagIsCheckedWithoutCheckingTheRestOfThePolicy(): void
+    {
+        // "middle" is only reachable as a trait, and the block carrying the
+        // forbidden filter is overridden by "index", so it never renders.
+        $sandbox = new Sandbox(self::env([
+            'index' => '{% use "middle" %}{% block content %}SAFE{% endblock %}',
+            'middle' => '{% use "leaf" %}{% block content %}{{ "bad"|upper }}{% endblock %}',
+            'leaf' => '',
+        ]), self::strictPolicy(tags: ['use', 'block']));
+
+        $this->assertSame('SAFE', $sandbox->render('index'));
+    }
+
+    public function testTheUseTagIsCheckedBeforeTheTraitTemplateIsLoaded(): void
+    {
+        $sandbox = new Sandbox(self::env([
+            'index' => '{{ block("b", "receiver") is defined ? "YES" : "NO" }}',
+            'receiver' => '{% use "missing" %}',
+        ]), self::strictPolicy(tags: ['block'], functions: ['block']));
+
+        $this->expectException(SecurityNotAllowedTagError::class);
+        $this->expectExceptionMessage('Tag "use" is not allowed');
+        $sandbox->render('index');
+    }
+
+    public function testAPolicyFailureWhileResolvingTraitsKeepsItsTwigContext(): void
+    {
+        $sandbox = new Sandbox(self::env([
+            'index' => "{% use \"empty\" %}\n{{ 'a'|upper }}",
+            'empty' => '',
+        ]), new ThrowingOnUseSecurityPolicy());
+
+        try {
+            $sandbox->render('index');
+            $this->fail('The policy failure should have been reported.');
+        } catch (RuntimeError $e) {
+            $this->assertStringContainsString('Policy backend unreachable', $e->getMessage());
+            $this->assertSame('index', $e->getSourceContext()?->getName());
+            $this->assertSame(2, $e->getTemplateLine());
+            $this->assertInstanceOf(\RuntimeException::class, $e->getPrevious());
+        }
+    }
+
     public function testARenderOnAnotherEnvironmentDuringASandboxedRenderIsNotSandboxed(): void
     {
         $app = new Environment(new ArrayLoader(['trusted' => '{{ value|upper }}']), ['autoescape' => false]);
@@ -369,6 +429,24 @@ class SandboxTest extends TestCase
     }
 }
 
+final class ThrowingOnUseSecurityPolicy implements SecurityPolicyInterface
+{
+    public function checkSecurity($tags, $filters, $functions, $tests = []): void
+    {
+        if (\in_array('use', $tags, true)) {
+            throw new \RuntimeException('Policy backend unreachable.');
+        }
+    }
+
+    public function checkMethodAllowed($obj, $method): void
+    {
+    }
+
+    public function checkPropertyAllowed($obj, $property): void
+    {
+    }
+}
+
 final class SandboxTestObject implements \Stringable
 {
     public $name = 'fabien';
diff --git a/tests/TemplateTest.php b/tests/TemplateTest.php
index e193d6c16..a3628b4c2 100644
--- a/tests/TemplateTest.php
+++ b/tests/TemplateTest.php
@@ -202,6 +202,54 @@ class TemplateTest extends TestCase
         $template->renderBlock('foo', [], ['foo' => [new TemplateForTest($twig, 'index.twig'), 'block_foo']], false);
     }
 
+    /**
+     * @dataProvider debugModes
+     */
+    #[DataProvider('debugModes')]
+    public function testRenderParentBlockRestoresOutputBuffersOnError(bool $debug): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'parent' => '{% block content %}{{ missing.value }}{% endblock %}',
+            'child' => '{% extends "parent" %}',
+        ]), ['debug' => $debug, 'strict_variables' => true, 'use_yield' => false]);
+        $template = $twig->load('child')->unwrap();
+        $level = ob_get_level();
+
+        try {
+            $template->renderParentBlock('content', []);
+            $this->fail('Rendering the parent block must fail.');
+        } catch (RuntimeError) {
+            $actualLevel = ob_get_level();
+        } finally {
+            while (ob_get_level() > $level) {
+                ob_end_clean();
+            }
+        }
+
+        $this->assertSame($level, $actualLevel);
+    }
+
+    public function testHasFixedParentOnlyReportsLineagesThatCanNoLongerMove(): void
+    {
+        $twig = new Environment(new ArrayLoader([
+            'no_parent' => '',
+            'constant_parent' => '{% extends "no_parent" %}',
+            'dynamic_parent' => '{% extends parent %}',
+        ]));
+
+        $this->assertTrue($twig->load('no_parent')->unwrap()->hasFixedParent());
+
+        $constant = $twig->load('constant_parent')->unwrap();
+        $this->assertFalse($constant->hasFixedParent());
+        $constant->getParent([]);
+        $this->assertTrue($constant->hasFixedParent());
+
+        $dynamic = $twig->load('dynamic_parent')->unwrap();
+        $this->assertFalse($dynamic->hasFixedParent());
+        $dynamic->getParent(['parent' => 'no_parent']);
+        $this->assertFalse($dynamic->hasFixedParent());
+    }
+
     public function testGetAttributeOnArrayWithConfusableKey(): void
     {
         $twig = new Environment(new ArrayLoader());
@@ -406,6 +454,12 @@ class TemplateTest extends TestCase
         $this->assertSame(0, $key->toStringCalls);
     }
 
+    public static function debugModes(): iterable
+    {
+        yield 'debug disabled' => [false];
+        yield 'debug enabled' => [true];
+    }
+
     public static function getStrictVariablesModes(): iterable
     {
         yield 'lax' => [false];
diff --git a/tests/TemplateWrapperTest.php b/tests/TemplateWrapperTest.php
index a39fbe354..970020343 100644
--- a/tests/TemplateWrapperTest.php
+++ b/tests/TemplateWrapperTest.php
@@ -136,6 +136,19 @@ class TemplateWrapperTest extends TestCase
         yield 'exception thrown by parent expression' => ['{% extends boom() %}', new TwigFunction('boom', static function (): never { throw new \DomainException('kaboom'); }), \DomainException::class];
     }
 
+    public function testBlockIntrospectionReportsTheExtendsLineForAMissingParent(): void
+    {
+        $twig = new Environment(new ArrayLoader(['index' => "\n\n{% extends 'missing' %}"]));
+
+        try {
+            $twig->load('index')->hasBlock('foo');
+            $this->fail('Introspecting a template with a missing parent must fail.');
+        } catch (LoaderError $e) {
+            $this->assertSame('Template "missing" is not defined.', $e->getRawMessage());
+            $this->assertSame(3, $e->getTemplateLine());
+        }
+    }
+
     public function testRenderBlock(): void
     {
         $twig = new Environment(new ArrayLoader([